Method and system for producing dynamic property forms and compacting property databases

ABSTRACT

A method and system for producing property forms for use in creating design schematics for an integrated circuit using computer-aided design apparatus wherein property forms are produced using a unique sophisticated cell library. The library includes a parameter database that includes base level component description format parameters which provide all of the information that is needed for creating the parameter labels, prompts, data boxes, selectors, etc. for property forms for each logic gate defined in a cell library and for a plurality of operating modes. This allows a single cell library to be used in the creation of a design schematic while permitting parameters of all logic gate instances to be specified at any one of three different design levels or modes, including a mode in which only the drive strength of n-channel type devices is specified, a mode in which the drive strengths of N and P type devices are specified, and a mode in which all of the parameters of all devices are specified. The information displayed on the property form can be customized by the user by entering customizing values for one or more of the base level parameters.

This application is a continuation of U.S. patent application Ser. No. 08/701,529, filed Aug. 26, 1996 now U.S. Pat. No. 5,757,655.

A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyrights whatsoever.

FIELD OF THE INVENTION

The present invention relates generally to the design of integrated circuits using computer-aided design apparatus, and in particular, the present invention relates to a method and system for producing property forms and compacting property databases in the computer-aided design of circuit design schematics, and wherein a unique sophisticated cell library is created which provides a parameter database that allows schematic design to be conducted in a plurality of design modes.

BACKGROUND OF THE INVENTION

In designing integrated circuits using computer-aided design apparatus, a design engineer produces a schematic of the integrated circuit that is being designed by selecting specific devices or sub-circuits from a device library and inter-connecting the terminals of the devices or sub-circuits as required to form the schematic. The device library contains digital data for producing representations of common devices or sub-circuits. The devices and sub-circuits are categorized in the library by design parameters and/or operating characteristics. Selection of a device or sub-circuit from the device library causes a representation of the selected device or sub-circuit to be displayed on the screen of a display unit.

Different design methodologies are used in the design of integrated circuit memory devices depending upon the type of integrated circuit device that is being designed. For example, in designing dynamic random access memory (DRAM) devices, circuit designers generally specify logic gates of such circuits in terms of their drive strengths. However, in designing static random access memory (SRAM) devices, circuit designers generally specify components of such circuits in terms of device parameters, such as channel length and width for the field-effect transistors that form the integrated circuit memory. Because the two design methodologies are based on different hierarchies, two device libraries are required, one library for use in the design of DRAM type memory devices and a separate library for use in the design of SRAM type memory devices. In many cases, a circuit designer may have to access both libraries during the design process. The need to access two different device libraries makes the circuit design process less efficient.

For the reasons stated above, and for other reasons stated below which will become apparent to those skilled in the art upon reading and understanding the present specification, there is a need in the art to be able to obtain logic gate drive strength and/or device parameters from a single cell library for use in creating a circuit schematic for an integrated circuit.

SUMMARY OF THE INVENTION

The present invention provides a method and system for producing property forms for use in creating a design schematic for an integrated circuit that is being designed using a computer-aided design apparatus. In accordance with the invention, a parameter database is provided that stores parameter data representing at least parameter labels and default expressions for parameter values for component description format parameters for the devices that form each of a plurality of circuits defined in a cell library and for each of a plurality of design modes. One of the design modes is selected and a circuit to be placed on the design schematic selected from the cell library. Then, the parameter database is accessed to obtain parameter data representing the parameter labels and the parameter default expressions for component description format of the selected circuit and for the selected design mode. The parameter data obtained is provided to the property form so that the property form includes parameter labels and parameter default expressions for component description format parameters of the current instance of the selected circuit for the selected design mode.

In accordance with another aspect of the invention, a value for at least one component description format parameter that is indicated by a default expression on the property form is entered onto the property form to produce design data for the current instance of the selected circuit, and the design data is saved in a further database. The saving of the design data includes compacting the further database.

In accordance with a further aspect of the invention, the parameter database is created by accessing at least one data structure to obtain first data indicating the number of devices that form each of a plurality of logic gates defined in the cell library and second data indicating the number of inputs for each of the logic gates defined in the cell library. The data is used to create for each of the logic gates, and for each of a plurality of design modes, a first set of component description format parameters, each set of the first set of parameters being unique to a different one of the logic gates. Then, a second set of component description format parameters is created for each of the logic gates and for each design mode. The parameters of second set of parameters being the same for all of the logic gates. The first and second sets of parameters provide the parameter data for the parameter database.

Further in accordance with the invention, there is provided a method and system for producing a property form for use in the creation of a design schematic for an integrated circuit that is being designed using a computer-aided design apparatus. In accordance with the invention, there is provided a parameter database storing base level parameter data representing at least parameter labels and standard default values for the component description format parameters for devices that form each of a plurality of circuits that are contained in a cell library. A customizing database is provided for storing customizing values for parameter default values for the parameters. A user level parameter database is created by accessing the parameter database to obtain the base level parameter data for a selected circuit. Then, for each parameter having a customizing value stored in the customizing database, the standard default value for the parameter is replaced with the customizing value so that the user level parameter database contains the customized value for the parameter. The user level parameter data is provided to the property form being produced.

In accordance with another aspect of the invention, there is provided a computer program product comprising a computer usable medium having computer readable program code means embodied therein for use in controlling a computer in the creation of a property form for use in the creation of a design schematic using a computer-aided design apparatus. The computer readable program code means in the computer program product includes computer readable program code means for causing a computer to provide a parameter database storing parameter data representing at least parameter labels and default expressions for parameter values for component description format parameters for the devices that form each of a plurality of circuits defined in a cell library and for each of a plurality of design modes. The invention further includes computer readable program code means for causing a computer to select one of the design modes and computer readable program code means for causing a computer to select a circuit to be placed on the design schematic. The invention further includes computer readable program code means for causing a computer to access the parameter database to obtain parameter data representing the parameter labels and the parameter default expressions for the component description format parameters of the selected circuit and for the selected design mode. In addition, computer readable program code means is provided for causing a computer to provide the parameter data obtained to the property form so that the property form includes parameter labels and parameter default expressions for component description format parameter of the current instance of the selected circuit for the selected design mode, and computer readable program code means is provided for causing a computer to enter onto the property form a value for at least one of the component description format parameters that is indicated by a parameter default expression on the property form to produce design data for the current instance of the selected circuit.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a symbol for a logic gate having parameters specified in terms of its drive strength for n-channel devices that form the logic gate;

FIG. 1A is a schematic circuit diagram for the logic gate of FIG. 1;

FIG. 2 is a symbol for a logic gate having parameters specified in terms of drive strengths for n-channel and p-channel devices that form the logic gate;

FIG. 2A is a schematic circuit diagram for the logic gate of FIG. 2;

FIG. 3 is a symbol for a logic gate having devices specified in terms of channel widths and lengths for the n-channel and p-channel devices that form the logic gate;

FIG. 3A is a schematic circuit diagram for the logic gate of FIG. 3;

FIG. 4 is a representation of a property form produced by the form interface provided by the invention for N mode;

FIG. 5 is a representation of a property form produced by the form interface provided by the invention for NP mode with default values expressed in terms of default expressions;

FIG. 6 is a representation of the property form of FIG. 5 and with some of the parameters specified by numerical values;

FIG. 7 is a representation of a property form produced by the form interface provided by the invention for Explicit mode;

FIG. 8 is a representation of the property form of FIG. 7 and with some of the parameters specified by numerical values;

FIG. 9 is a block diagram of a computer system for creating a form database for use in creating circuit schematics in accordance with the invention;

FIG. 10 is a block diagram of a form create engine including known form create and gate create drivers, and gate create and form create formatters provided by the invention;

FIG. 11 is a process flow chart illustrating the operation of the form create engine in creating a form database for use producing property forms;

FIG. 12 illustrates the information contained in the look-up structure Gate Count;

FIG. 13 illustrates the information contained in the look-up structure Gate Stack;

FIG. 14 is a process flow chart illustrating how the form create formatter creates a library cdf parameter database for use in producing property forms;

FIG. 15 is a process flow chart illustrating how the form create formatter creates parameters for the library cdf parameter database that is produced by the process of FIG. 14;

FIG. 16 is a block diagram of a schematic create engine including a known circuit schematic create driver, a known form displayer, and a property form transformer and a database compactor provided by the invention;

FIG. 17 is a process flow chart illustrating the steps taken by the schematic create engine in creating a property form using the database provided by the invention and in providing different property form formats for different design modes in accordance with the invention;

FIG. 18 is a process flow chart illustrating how the form transformer updates parameters that are read from the library cdf parameter database in producing property forms;

FIG. 19 is a process flow chart illustrating how the form transformer updates property forms as to the display of node potentials and customizes Add Component forms;

FIG. 20 is a representation of an Add Component form that is produced upon placing a logic gate instance on a schematic;

FIG. 21 is a process flow chart illustrating how the form transformer updates parameter values being displayed on a property form;

FIG. 22 is a process flow chart illustrating how the database compactor screens parameter default values and purges parameters when parameter data is being saved to the instance database;

FIG. 23 is a process flow chart illustrating how the database compactor screens parameter default values for the bulk node connection parameter when an instance is placed on the schematic;

FIG. 24 is a representation of the initial property form that is displayed upon entering N mode;

FIG. 25 is a representation of the property form that is displayed upon entering NP mode after drive strength has been specified;

FIG. 26 is a representation of the property form of FIG. 25 after screening out default parameter values;

FIG. 27 is a representation of the property form of FIG. 26 after a parameter value has been entered for drive strength of p-channel devices;

FIG. 28 is a representation of the property form that is displayed upon entering Explicit mode after drive strengths have been specified for n-channel and p-channel devices;

FIG. 29 is a representation of the property form of FIG. 28 after screening out default parameter values;

FIG. 30 is a listing of an exemplary code segment for the procedure "MScdfGateCreateBaseParam( )";

FIGS. 30A, 30B and 30C are a listing of an exemplary code segment for the procedure MS₋₋ cdfGateCreate;

FIGS. 31 and 31A are a listing of an exemplary code segment for the procedure MS₋₋ cdfGateExplicit;

FIG. 32 is a listing of an exemplary code segment for the procedure MScdfLibCreateBaseParam( );

FIGS. 33, 33A and 33B are a listing of an exemplary code segment for the procedure MScdfLibCreateParam( );

FIG. 34 is a listing of an exemplary code segment for the procedure MScdflibCreateUserParam( );

FIG. 35 is a listing of an exemplary code segment for the procedure MScdfGateIP( );

FIG. 36 is a listing of an exemplary code segment for the procedure MScdfGateModeCB( );

FIG. 37 is a listing of an exemplary code segment for the procedure MScdfGateDP( );

FIGS. 38 and 38A are a listing of an exemplary code segment for procedures MS₋₋ cdfGateVerifyN; MS₋₋ cdfGateVerifyNP; and MS₋₋ cdfGateVerifyExplicit;

FIG. 39 is a listing of an exemplary code segment for the procedure MS₋₋ cdfGatePurgeNP;

FIG. 40 is a listing of an exemplary code segment for the procedure MS₋₋ cdfGatePurgeExplicit; and

FIG. 41 is a listing of an exemplary code segment for the procedure MS₋₋ cdfGateVerifyBulk( ).

DESCRIPTION OF THE PREFERRED EMBODIMENT

In the following detailed description of the preferred embodiment, reference is made to the accompanying drawings which form a part hereof, and in which is shown by way of illustration a specific preferred embodiment in which the invention may be practiced. The preferred embodiment is described in sufficient detail to enable those skilled in the art to practice the invention, and it is to be understood that other embodiments may be utilized and that logical, mechanical and electrical changes may be made without departing from the spirit and scope of the present invention. The following detailed description is, therefore, not to be taken in a limiting sense, and the scope of the present invention is defined only by the appended claims.

Device Representation

The present invention is described with reference to an application for creating a circuit schematic that includes an instance GNA0 of a conventional NAND gate, the symbol 20 of which is shown in FIG. 1. However, as will be shown, in accordance with one aspect of the invention, a database is created which permits a single unique sophisticated library of logic gates or other circuits to be used with conventional schematic design tools. The design tools receive user-supplied functions, also provided by the invention, allowing schematic design to be conducted on the basis of logic gate drive strength and/or device parameters, using a single cell library.

Logic gates can be added to a circuit schematic based on drive strength or on an explicit basis. In the former mode, the logic gate being placed on a schematic is represented by a symbol of the logic gate, such as NAND gate GNA0, having its drive strength specified. Conventionally, the drive strength is represented by the width of the gate region of the n-channel transistors that form the logic gate. In this mode, when a logic gate is called from a cell library, the information that is displayed on the screen is as shown in FIG. 1.

The logic gate can also be represented on an explicit level in which the width and length of the elements, including n-channel and p-channel transistors, that form the logic gate are specified. When a logic gate is called from a cell library, the information that is displayed at the explicit level is as shown in FIG. 3 for NAND gate GNA0. Known schematic design tools require separate device libraries for these two modes of design.

Operating Modes

In accordance with the invention, a database is created which permits a single standard cell library to be used, allowing logic gates to be specified either by drive strength or in terms of explicit parameters. The invention automatically converts from drive strength to explicit parameters or from explicit parameters to drive strength in response to mode selection commands provided by the circuit designer. In addition, the invention provides an intermediate design level in which gate elements, such as NAND gate GNA0 shown in FIG. 2, can be specified in terms of the drive strengths for the n-channel transistors and the p-channel transistors that form the logic gate. Thus, in one embodiment, the invention provides three design levels or modes, hereinafter referred to as "N mode", "NP mode", and "Explicit mode". In N mode (FIG. 1), gate size is specified in terms of one single drive strength for the gate. In NP mode (FIG. 2), the gate size is specified in terms of the drive strengths for two types of devices, i.e., the n-channel and the p-channel devices, that form the logic gate. In Explicit mode (FIG. 3) the parameters of each gate device are specified in terms of parameters for all of the devices that form the logic gate.

To illustrate this, reference is made to FIGS. 1-3. FIG. 1 illustrates the symbol 20 that is displayed on the display screen of a computer-aided design (CAD) apparatus for the NAND gate GNA0 when the N mode is selected. Contained within the symbol 20 is the notation "10", which indicates that the NAND gate GNA0 has a drive strength of ten.

The NAND gate GNA0 also can be represented by the schematic of FIG. 1A. As shown in FIG 1A, the NAND gate GNA0 includes p-channel transistors MPA and MPB and n-channel transistors MNA and MNB. The gates of MPA and MNA are commonly connected to a node A. Thus, the suffix "A""A""A" for the transistors MPA and MNA. The gates of MPB and MNB are commonly connected to a node B. Thus, the suffix "B" for the transistors MPB and MNB. The sources of MPA and MPB are connected to a voltage source vcc in the conventional manner. The drains of MPA and MPB are commonly connected to a node Y. MNA and MNB are connected in series between node Y and ground. In the example, the widths wnA and wnB of the n-channel transistors MNA and MNB are specified as being "20" and the lengths lnA and lnB of MNA and MNB are default values as indicated by the notations NDEFL. The drive strength Wn for the NAND gate GNA0 is expressed by the default expression iPar("NDEFW") which is equal to "10" in the example. The drive strength of the logic gate expressed in terms of lengths LnA and LnB of the n-channel transistors is given by default expression iPar("NDEFL").

The expression "iPar()" is a function in a parameter passing environment known as Cadence Expression Language (CEL). The function "ipar()" passes parameters locally, obtaining the value of the parameter from the current instance or from a library database that is created in accordance with the invention as will be described.

For the p-channel transistors, the drive strength Wp is specified in terms of a ratio of the width of the n-channel transistors. The drive strength Wp is expressed as "iPar(PNR)*iPar(Wn)". The term "PNR" represents the nominal ratio of device sizes between P-type and N-type. In the example, the term PNR is equal to 1.5 and as will be shown, the drive strength Wp of the p-channel transistors is "15" in the example. The drive strength of the logic gate expressed in terms of lengths LpA and LpB of the p-channel transistors is given by default expression iPar("PDEFL").

FIG. 2 illustrates the symbol 22 that is displayed on the display screen of a computer-aided design (CAD) apparatus when the NP mode is selected for the NAND gate GNA0. In this mode, the symbol 22 for NAND gate GNA0 includes the notations "P=20" and "N=10". The notation "P=20" indicates the drive strength of the p-channel devices and corresponds to the width of the p-channel devices. The notation "N=10" is the drive strength for n-channel devices of the logic gate, as indicated in FIG. 1, and is derived from the channel widths of the n-channel devices. referring now to FIG. 2A, the detailed schematic for NAND gate GNA0 is the same is that of FIG. 1A, except that the designations for the p-type transistors have been changed to indicate that the drive strength of each p-channel transistor is specified as being "20" in the example.

FIG. 3 illustrates the symbol 24 that is displayed on the display screen of a computer-aided design (CAD) apparatus when the Explicit mode is selected for the AND gate GNA0. In this mode, the symbol 24 for NAND gate GNA0, which is shown in FIG. 3, includes the notations "PB=15/1" and "PA=15/1" which indicate that the p-channel transistors have a width of "15" and a length of "1" in the example. The gate GNA0 also includes the notations "NA=22/1" and "NB="22/1" which mean that the n-channel transistors have a width of "22" and a length of "1" in the example. Referring to FIG. 3A, in this mode, the lengths of the p-channel transistors and the n-channel transistors are specified as being "1".

Property Forms

In adding a gate to a schematic, the parameters of the gate are displayed on an "Edit Object Properties" screen or "property form", such as property form 400 shown in FIG. 4. The upper portion of the property form illustrated in FIG. 4, i.e., the portion of the property form 400 indicated by the bracket 402, corresponds to the property form that is produced by a schematic design program, or design tool, such as the DF2 schematic design programs commercially available from Cadence Design Systems, Inc., San Jose, Calif. Such a schematic design tool produces the information contained in the upper portion 402 of the property form, specific data, such as the library name, "slib"; the cell name "2nand"; the view name "symbol" and the instance name "GNA0" being produced in response to data supplied by the circuit designer in selecting a gate instance for placing on a schematic.

The invention customizes the property form provided by the schematic design tool by providing the information that appears on the lower portion 404 of the screen 400 which includes labels for user-defined component description format (cdf) parameters, and values for the library cdf parameters. The library cdf parameters include "m", "toolFilter" and "gateSize". The library cdf parameters are displayed on the form as prompts "m (local multiplier)" 410, "tool Filter"412, and "gateSize" 414. Also, gate level parameters are displayed as "Wn (drive strength)" 416, "bnP (Bulk node)" 418 and "bnN (Bulk node)" 420. These library cdf parameters, or library level parameters, are created by procedures provided by the invention.

In the exemplary embodiment, the values for these user-defined parameters are specifiable as follows. The local multiplier "m" can be any numerical value. The choices for the tool Filter are" "(i.e., none), "Ivs", "hsp", and "all". The choices for gateSize (or operating mode) are "N", "NP", and "explicit". The choices for the PMOS bulk node potential parameter bnP are "vpp|"and "vcc|". The choices for the NMOS bulk node potential parameter bnN are "vbb|" and "gnd|". In N mode, drive strength Wn is specified as the default expression iPar("NDEFW"). Additionally, in NP mode and Explicit mode, drive strength Wp is expressed in terms of the default expressions "iPar(PNR)*iPar(Wn)", iPar("PDEFL") and iPar("NDEFL"). Also, in Explicit mode, device parameters are expressed in terms of the default expressions iPar("Wp"), iPar("Wn"), iPar("Lp") and iPar("Ln") for each device of the logic gate. The terms PNR, NDEFW, PDEFL, and NDEFL are global variables, the values of which are user-definable as will be described.

The parameter "m" (local multiplier) allows the circuit designer to apply a constant multiplier for simulation by entering a numerical value into databox 411.

The parameter "toolFilter" allows the circuit designer to select a simulator using a "radio" type selector 413 with the choices of tool filters being represented by symbols labeled "Ivs", "hsp", "all" and an unlabeled symbol representing that no tool filter has been selected. The parameter "gateSize" allows the circuit designer to select the operating mode using a "radio" type selector 415 with the choices for the modes being represented by symbols labeled "N", "N, P" and "explicit". The value for the parameter drive strength "Wn", for example, is displayed in a data box 417 as the expression "iPar ("NDEFW")" unless a value for drive strength has been specified in which case the numerical value is displayed in data box 417. In the exemplary embodiment, the number "10" is being displayed in data box 417. The parameter "bnP" allows the circuit designer to select a bulk potential for PMOS devices using a "radio" type selector 419 with the choices of the potentials available being represented by symbols labeled "vpp|" and "vcc|". Similarly, the parameter "bnN" allows the circuit designer to select a bulk potential for NMOS devices using a "radio" type selector 421 with the choices of the potentials available being represented by symbols labeled "vbb|" and "gnd|". In the example, a default value of "1" is displayed in data box 411, no tool filter is specified, and N mode is selected as indicated at 415. Also, data box 417 is shown to include the number "10" for drive strength Wn for instance GNA0 of the NAND gate. Parameters "bnP" and "bnN" are specified as vpp| and vbb|, respectively, as indicated at 419 and 421.

To change from N mode to NP mode, the circuit designer selects the "N, P" for "gateSize" 414 on the property form. For NP mode, the property form can appear as the property form 500 illustrated in FIG. 5, in which default expressions are displayed, or as the property form 600 in FIG. 6, in which default expressions have been changed to numerical values. Referring to FIG. 5, as can be seen, the "gateSize" 414 has been changed to indicate, at 502, the selection of NP mode. Also, three labels 504, 506 and 508 have been added, along with respective data boxes 510, 512 and 514, with the boxes being provided to the right of the labels. One of the labels 504 is "Wp (drive strength)" and the corresponding data box 510 contains the default expression "iPar("PNR") * iPar("Wn")" for drive strength Wp. Another one of the labels 506 is "Lp" and corresponding data box 512 contains the default expression "iPar("PDEFL")". The third label 508 is "Ln" and the corresponding data box 514 contains the default expression "iPar("NDEFL")".

FIG. 6 illustrates how the appearance of the property form 600 for NP mode is changed when parameter data is entered into the data boxes 510, 512 and 514. In the example, a value of "20" is entered into box 510 for the drive strength parameter Wp. The parameter data contained on the property form 600 corresponds to the information that is provided on the symbol 22 in FIG. 2, wherein P=20 which represents the drive strength Wp for the p-channel transistors and N=10, which represents the drive strength Wn for the n-channel transistors.

To change from NP mode to Explicit mode, the circuit designer selects the position "explicit" in the gateSize selection function 414 on the property form 600. In explicit mode, the property form can appear as shown for the property form 700 illustrated in FIG. 7. Referring to FIG. 7, as can be seen, the "gateSize" indicator 414 indicates, at 702, the selection of Explicit mode. Also, eight labels 704, 706, 708, 710, 712, 714, 716 and 718 have been added, along with respective data boxes 724, 726, 728, 730, 732, 734, 736 and 738, with the boxes being provided to the right of the labels for entering values for device parameters, including channel widths wpA, wnA, wpB and wnB, and channel lengths lpA, lnA, lpB and lnB for transistors MPA, MNA, MPB and MNB. Label 704 is "wpA" and the corresponding data box 724 contains the default expression "iPar("Wp")" which means that the channel width wpA of MPA is specified in terms of the drive strength Wp. Label 706 is "wnA" and corresponding data box 726 contains the default expression "iPar("Wn")*2". Label 708 is "lpA" and the corresponding data box 728 contains the default expression "iPar("Lp")". Label 710 is "lnA" and corresponding data box 730 contains the default expression "iPar("Ln")". Label 712 is "wpB" and the corresponding data box 732 contains the default expression "ipar("Wp")". Label 714 is "wnB" and corresponding data box 734 contains the default expression "iPar("Wn")*2". Label 716 is "lpB" and the corresponding data box 736 contains the default expression "iPar("Lp")". Label 718 is "lnB" and corresponding data box 738 contains the default expression "iPar("Ln")".

Referring now to FIG. 8, there is illustrated a property form 800 for Explicit mode when numerical values are entered in the data boxes 724, 726, 728, 730, 732, 734, 736 and 738. In the example, the number "15" has been entered into data box 724. The number "22" has been entered into data box 726. The number "1" is displayed in data boxes 728 and 730. The number "15" has been entered into data box 732. The number "22" has been entered into data box 734. The number "1" has been entered into data boxes 736 and 738. The parameter data contained on the property form 800 corresponds to the information that is provided for the gate GNA0 shown in FIG. 3.

The foregoing examples illustrate changes that are made in the property form for the different design modes which are selectable by the circuit designer. It is pointed out that the circuit designer can change to any mode at any time. For example, the circuit designer can change from Explicit mode either to NP mode or to N mode. Also, when in NP mode, the circuit designer can change back to N mode. In each case, the appropriate property form will be provided automatically. However, when values have been entered into the property form, such values will be shown rather than the default expressions.

For N mode, the drive strength Wn for the logic gate is related to the size of the n-channel devices and is given by the expression Wn="iPar("NDEFW")". The value of NDEFW is selected by the circuit designer. In the example, a non-default value of "10" has been selected for the parameter NDEFW. Thus, the drive strength Wn is equal to "10". In NP mode, the drive strength for the logic gate is expressed in terms of drive strength Wn and Wp for both n-channel devices and p-channel devices. The drive strength expressed in terms for the p-channel devices is given by the default expression Wp="iPar("PNR")*iPar("Wn")". In the example, "PNR" is equal to "1.5". Thus, in the example, the default value for Wp is equal to "15", but a value of "20" has been entered as shown in FIG. 6. Also, default values for Lp and Ln are selected to be "1.5" in the example, and so the default expression is displayed for parameters Lp and Ln as shown in FIG. 6. Note that in this description, the drive strengths are represented by upper case letters, such as Wn, Wp, Ln and Lp, whereas device sizes are represented are expressed in lower case letters for the prefixes of device parameters such as prefixes "wn" or "wp" of device parameters wnA, wnB, wpA, wpB, etc.

Computer System

FIG. 9 is a block diagram of a computer system 905 in which the present invention is capable of being executed. A processing unit 910 is connected to input devices 925 which can include a computer keyboard, a mouse and/or a digital drawing pad. The processing unit 910 is connected also to storage devices 930, a printer 945 and a display unit with a screen 960. Computer system 905 can be an engineering workstation such as that available from Sun Microsystems in Palo Alto, Calif. Typically, such workstation is connected to a local area network which provides access to the storage devices 930 and has Ethernet connections to the printer 945.

The storage devices 930 include programs and files of the computer system 905 which are used in the creation of a schematic database using the procedures provided by the invention. The programs and files of the computer system 905 include an operating system 931, a gate create engine including a form create driver 932 and a gate create driver 933, and a schematic create engine including a schematic create driver 1610, and a form displayer 1620.

The storage devices 930 also include programs and files provided by the invention including form create and gate create formatters 934, a gate cdf database 935, a library cdf database 936, user level data storage 937, cell database 938, a form transformer 1615, a database compactor 1616, an object database 1635 and a user schematic database 1638. Associated with the formatters 934 are a Gate Count data structure 934a, a Gate Stack data structure 934b, and a data structure 934c. Additional data storage include a central text file 939 ".simrc", miscellaneous data storage 940, a standard cell library slib 1030 and a user design library 1630. It is pointed out that although in the exemplary embodiment, the gate cdf database 935, the library cdf database 936 and the cell database 938 are illustrated as being a separate database, these databases are sub-databases of the library slib 1030.

Form Create Engine

FIG. 10 is a block diagram of the form create engine 1020 for creating a database for use in producing schematics in accordance with the invention. The form create engine 1020 includes conventional form create driver 932 and conventional gate create driver 933 which are provided, for example, as the skeleton programs of the DF2 schematic design programs commercially available from Cadence Design Systems, Inc., San Jose, Calif. The Cadence DF2 schematic design programs are adapted to receive user-supplied design functions.

The form create engine 1020 has associated therewith the standard library slib 1030 and a cell database 938, which is a sub-database of the library slib 1030. The library slib 1030 is the standard cell library for the instances or objects that can be placed on schematic by a circuit designer, such as, but not limited to, circuits or logic gates such as the logic gates listed in FIGS. 12 and 13, for example. Each cell database 938 contains a symbol database (for example, symbol 20 in FIG. 1), a schematic database (for example, the schematic shown in FIG. 1A) and a cdf parameter database 935.

The gate create and form create formatters 934 of the form create engine 1020, which are provided by the invention, provide user-supplied design functions to the gate create driver 933 and the form create driver 932 for creating the gate cdf database 935 and the library cdf database 936, and for using the cdf databases 935 and 936 for producing property forms for use in creating circuit schematics. The gate cdf database 935 is a sub-database of the cell database 938. The library cdf database 936 is a sub-database of the library slib 1030. The user level parameter data storage 937 stores user level data that is generated in response to opening the standard library 1030 as will be described.

The user-supplied functions provided by the formatters 934 of the invention include the procedures "MS₋₋ cdfGateCreateBaseParam()", "MS₋₋ cdfGateCreate"; "MS₋₋ cdfGateExplicit"; "MScdfLibCreateBaseParam()" and "MScdfLibCreateParam()". These functions are used in creating the parameter database that comprises the gate cdf database 935 and the library cdf database 936 that are used in producing property forms for the three operating modes, N mode, NP mode, and Explicit mode. The formatters 934 include a further user-supplied function "MScdfLibCreateUserParam()" that is used in customizing the property forms.

                  TABLE I     ______________________________________     VARIABLE DEFINTIONS     ______________________________________     LIBRARY = slib     .sub.-- MS.sub.-- CDF.sub.-- DEV = `nil     .sub.-- MS.sub.-- CDF.sub.-- POWER.sub.-- LIST = list ("vpp|""vcc|")     .sub.-- MS.sub.-- CDF.sub.-- GROUND.sub.-- LIST = list ("vbb|""gnd|")     .sub.-- MS.sub.-- CDF.sub.-- LIB.sub.-- PARAM.sub.-- SET =     `(gateSize m toolFilter bnPLib     bnNLib paramX paramY)     .sub.-- MS.sub.-- CDF.sub.-- GLOBAL.sub.-- VAR = `(PNR NDBEW PDEFL     NDEFL)     .sub.-- MS.sub.-- CDF.sub.-- LIB.sub.-- PARAM.sub.-- ALL = append     (.sub.-- MS.sub.-- CDF.sub.-- GLOBAL.sub.-- VAR     .sub.-- MS.sub.-- CDF.sub.-- LIB.sub.-- PARAM.sub.-- SET)     ______________________________________

TABLE I illustrates variable definitions that are contained in the data structure 934c. The variable definitions are used in the procedures "MS₋₋ cdfGateCreate","MS₋₋ cdfGateExplicit", MScdfLibCreateBaseParam()", "MScdfLibCreateParam()", "MScdfLibCreateUserParam()" and other procedures, in producing the display forms. The data structure Gate Count 934a, the data structure Gate Stack 934b, and the data structure 934c preferably are program functions which comprise portions of the software programs of the formatters 934, and/or portions of the form transformer 1615 which will be described.

The variable definitions contained in the data structure 934c include the variable ₋₋ MS₋₋ CDF₋₋ DEV, which is a display control parameter which, when set equal to "nil", prevents parameters from being displayed. The library database also includes lists of choices for the parameters bnP and bnN. In the exemplary embodiment, the choices for parameter bnP are "vpp|" and "vcc|" and are listed in a POWER list in that order, and the choices for parameter bnN are "vbb|" and "gnd|" and are listed in a GROUND list in that order. However, additional choices can be defined for the parameters bnP and bnN.

The data structure 934c also defines a list ₋₋ MS₋₋ CDF₋₋ LIB₋₋ PARAM₋₋ SET, which is a set of library cdf parameters, including the parameters "gateSize", "m", "toolFilter", "bnPLib", "bnNlib", "paramX" and "paramY". The data structure 934c defines a list ₋₋ MS₋₋ CDF₋₋ GLOBAL₋₋ VAR, which is a set of global variables, including "PNR", "NEDFW", "PDEFL", and "NDEFL". These two lists of variables are combined by a procedure "append" to form a variable MS₋₋ CDF₋₋ LIB₋₋ PARAM₋₋ ALL". The information contained in the data structure 934c is accessed by the formatters 934 in creating the parameter database and by the form transformer 1615 and other procedures in producing the display forms.

The form create driver 932, the gate create driver 933 and the formatters 934 can be software programs residing in computer system 905, or any other suitable media or computer program product that is capable of providing a computer readable program code. In one embodiment, the form create driver 932, the gate create driver 933 and the user-supplied functions which comprise the formatters 934 are written in SKILL code, a computer language provided by Cadence Design Systems, Inc., San Jose, Calif. In other embodiments, other computer languages, such as C++, Pascal, and SmallTalk computer languages can be used as well.

Database Creation

The user-supplied functions "MScdfGateCreateBaseParam()"; "MS₋₋ cdfGateCreate"; "MS₋₋ cdfGateExplicit"; "MScdfLibCreateBaseParam()" and "MScdfLibCreateParam()" provided by the invention are used in creating the databases that are used in producing property forms for the three operating modes, N mode, NP mode, and Explicit mode. The gate cdf parameter database 935 contains information needed to produce a portion of the property forms for the three operating modes, for each of the cells or logic gates, for example, contained within the library slib 1030. The procedure "MScdfGateCreateBaseParam()" steps through all the logic gates in the library slib 1030 using the procedures "MS₋₋ cdfGateCreate" and "MS₋₋ cdfGateExplicit" to create gate cdf parameters for all of the property forms for each logic gate in the library slib 1030, and for each of the three operating modes.

The library cdf parameter database 936 includes those parameters which are generic to all of the logic gates in the library slib 1030. The data contained in the library cdf parameter database 936 provides, for example, labels, data boxes and "radio" type selectors for displaying the cdf parameter information, and the default expressions for the global variables, on the property forms for the three operating modes as will be described after the description of the gate creation procedure.

The following description of the gate creation procedure makes reference to FIGS. 9-11. FIG. 11 is a process flow chart illustrating the steps taken by the form create engine 1020 in creating the gate cdf database 935 that is used in creating design schematics, using the DF2 schematic design tool available from Cadence Design Systems, Inc.

Referring to FIGS. 9-11, the procedure "MScdfGateCreateBaseParam()" of formatters 934 is entered at step 1102 and at step 1104 calls the procedure "MS₋₋ cdfGateCreate()"control to the gate create driver 933 which executes a function "cdfCreateparam("inputs")" which accesses the look-up structure GateCount 934a to determine the number of inputs for the logic gate for which the property form database is being created. Referring to FIG. 12, in the look-up structure 934a, the inputs for each cell are listed and are indexed with the cell name. In the present example, NAND gate GNA0 is represented in the look-up structure as "2nand", which is indicated by reference numeral 1202, and has two inputs, as indicated by the number "2" in line 1202. The number of inputs for the current instance is used in creating the labels associated with the gate parameters.

Referring again to FIGS. 9-11, the procedure continues to step 1108 and creates the gate parameter Wp. In creating a parameter, such as parameter Wp, the information that is generated includes the prompt "Wp (drive strength)", and the data format or type. Also created is the default value "defValu" for the parameter, which is represented by the default expression "iPar("PNR")*iPar("Wn")" for parameter "Wp" in the example. This information is set forth in lines 3019-3021 of the source code, an exemplary code segment of which is provided in FIGS. 30A, 30B and 30C. The information or create parameter data for each of the cdf gate parameters that is created is set forth in the source code. The parameter data is stored in the gate cdf database 935. As there shown in lines 3022-3026, for example, other information that is produced in creating the parameter Wp includes "?display" which indicates the form in which the parameter value is displayed in certain operating modes. Additional information that is created for parameter Wp includes "?parseAsCEL", which enables Cadence Expression Language (CEL) capability to evaluate an expression; "?parseAsNumber" which enables a non-numerical parameter type to be treated as a number; and "?editable" which indicates that the user can edit the parameter on the display form. Similar information is produced for the other gate cdf parameters. Other information provided for some of the parameters includes, a display control parameter, MS₋₋ CDF₋₋ PARAM. When the display control parameter is true, the associated parameter will be displayed. When the display control parameter is not true, the associated parameter will not be displayed.

Then, the procedure continues to step 1110 and creates the gate parameter "Wn (drive strength)", providing similar information including the prompt "Wn (drive strength)" and the default expression, which is "iPar ("NDEFW")"for the parameter "Wn" in the exemplary embodiment. This data is stored in the gate cdf database 935.

The procedure continues to step 1112 and creates similar information for the gate parameters "Lp", including the prompt "Lp" and the default expression "iPar("PDEFL")". This data is stored in the gate cdf database 935. At step 1114, the procedure creates the parameter "Ln", including the prompt and the default expression "iPar("NDEFL")" for the parameter "Ln". This data is stored in the gate cdf database 935.

The procedure continues to step 1116 which calls the procedure cdfGateExplicit()" of the formatters 934. This procedure creates additional parameters for the property form for Explicit mode. This procedure returns a string that indicates by how much Wp and Wn have to be multiplied in order to retain equivalent drive strength of an inverter with the size Wn or Wp. Also, the procedure determines the number of devices that comprise the current gate instance by accessing the Gate Count look-up structure 934a, as represented by the block 1117 labeled "gate inputs", which information is provided by step 1106.

Digressing, with reference to FIG. 1A, the two p-channel transistors MPA and MPB, of instance "M", are connected in parallel between the voltage source vcc and node Y, whereas the two n-channel transistors MNA and MNB of instance "M", are connected in series between node Y and ground. Although the n-channel transistors have a channel width of "20", the effective channel width is "10". As shown in FIG. 1, the gate strength, which is represented by the width of the n-channel transistors is indicated as being "10". Consequently, when the n-channel transistors MNA and MNB are specified on an explicit level, the parameter drive strength "Wn", which is "10" in the example, has to be multiplied by "2". See, for example, the data in box 726 in FIG. 7. This information is contained in the look-up structure GateStack 934b (FIG. 13) which is accessed by the procedure "MScdfGateExplicit" in creating the suffix, A, B, C, etc. for the parameter labels for the device parameters wp, wn, lp and ln. In the present example, the procedure returns the parameter labels wpA, wnA, lpA and lnA, along with wpB, wnB, lpB and lnB. The Gate Count look-up structure 934a indicates the number devices that are included in the current gate instance.

Referring to FIGS. 11 and 13, steps 1118-1130 create suffixes for all instances of the current logic gate, with steps 1120-1130 being performed by the gate create driver 933. Step 1120 accesses the look-up structure Gate Stack 934b, shown in FIG. 13, to return a string that indicates by how much Wp has to be multiplied in order to retain equivalent drive strength of an inverter with the size wp. In the present example, the information for a 2-input NAND gate is contained in line 1302. The information that is provided by the look-up structure 934b is represented as: NA=2 PA=1, NB=2 and PB=1. This indicates that the drive strength Wp is multiplied by one to obtain the widths wpA and wpB of the two p-channel transistors PA and PB. In the present example, this results in no change in the way the parameters wpA and wpB are shown in data boxes 724 and 732 of FIG. 7 when Explicit mode is called. The multiplier data obtained by step 1120 is stored in the gate cdf database 935.

Similarly, step 1122 returns a string that indicates by how much Wn has to be multiplied in order to retain equivalent drive strength of an inverter with the size wn. The procedure again accesses the look-up structure GateStack 934b which is shown in FIG. 13, and determines that for the channel width parameters wnA and wnB of the two n-channel transistors NA and NB, drive strength Wn has to be multiplied by two. In the example, this fact is indicated in the data boxes 726 and 734 of FIG. 7 when Explicit mode is called. The multiplier data obtained by step 1122 is stored in the gate cdf database 935.

As the procedure continues, steps 1124-1130 perform a string concatenate function to add a letter suffix to each of the parameter labels. The first letter suffix is "A", the second letter suffix is "B" , etc. Step 1124, creates parameter wpA, at step 1126, creates parameter wnA, at step 1128, creates parameter lpA and, at step 1130, creates parameter lnA. The procedure then loops back to step 1118 which determines that a set of parameters with the suffix "B" has to be created for the present example. Accordingly, the same sequence is followed in creating parameters wpB, wnB, lpB and lnB. Because in the present example, all gate level parameters needed have been created, the procedure is done. The gate parameter data created by the procedure is stored in the gate cdf database 935.

The following description of the library parameter database creation procedures, including the procedures "MScdfLibCreateBaseParam()"and "MScdfLibCreateParam()", makes reference to FIGS. 9-10, 14 and 15. These procedures create a "base" level cdf database which is called the library cdf parameter database 936 and which is similar to the gate cdf parameter database 935 created by procedure MS₋₋ cdfGateCreate(). Preferably, the library cdf parameter database 936 is created prior to creating the gate cdf parameter database 935. The library cdf parameter database 936 includes those parameters which are generic to all of the logic gates in the library slib 1030. In the exemplary embodiment, these parameters include "m" (local multiplier), "toolFilter", "gateSize" ,"bnPLib" (bulk potential for PMOS devices), "bnNLib "(bulk potential for NMOS devices), "paramX" and "paramY" which comprise a set of parameters called "₋₋ MS₋₋ CDF₋₋ LIB₋₋ PARAMS₋₋ SET". The library cdf parameter database also includes the four global variables PNR, NDEFW, PDEFL, and NDEFL. The global variables PNR, NDEFW, PDEFL, and NDEFL comprise a set of variables called ₋₋ MS₋₋ CDF₋₋ GLOBAL VAR". The set "₋₋ MS₋₋ CDF₋₋ LIB₋₋ PARAM₋₋ SET" and the set "₋₋ MS₋₋ CDF₋₋ GLOBAL₋₋ VAR" comprise a group of parameters "MS₋₋ CDF₋₋ LIB₋₋ PARAM₋₋ ALL".

The procedure "MScdfLibCreateBaseParam()"creates the labels, data boxes and "radio" type selectors that are needed to display the library cdf parameters and the default expressions for the global variables. A process flow chart for the procedure "MScdfLibCreateBaseParam()" is given in FIG. 14. A process flow chart for the procedure "MScdfLibCreateParam()", which is called by the procedure "MScdfLibCreateBaseParam()", is given in FIG. 15.

Referring to FIGS. 9-10 and 14, procedure "MScdfLibCreateBaseParam()" is entered at step 1402. During updating of the library cdf database 936 to add logic gates or parameters, steps 1404-1406 are used to delete any previously created cdf parameter data from the library cdf database 936. The procedure deletes the library cdf database 936 if one exists. Any library cdf parameters that were previously created are deleted because steps 1408-1414 of the procedure re-create all of the library cdf parameters "m", "toolFilter", "gateSize","bnPLib", "bnNLib", "paramX" and "paramY" and the global variables PNR, NDEFW, PDEFL, and NDEFL. In creating each of the parameters, step 1410 calls the procedure "MScdfLibCreateParam()" for creating each parameter and each global variable in sequence. Step 1412 saves the cdf parameter data in the library cdf database 936.

Referring to FIG. 15, the procedure "MScdfLibCreateParam()" starts at step 1502. Step 1504 determines if the parameter being processed is a member of the group of variables "₋₋ MS₋₋ CDF₋₋ GLOBAL₋₋ VAR" and if so, step 1506 calls procedure "cdfCreateParam()" which creates the parameter. In creating each of the global variables, the procedure creates a prompt, the default value for the parameter, the form in which the parameter is presented, and other information required to display the parameter. The information that is produced in creating the global variables and the library cdf parameters is similar to that created for the gate cdf parameters as is described above with reference to FIGS. 11 and 30A-30C. For the global variables and the library cdf parameters, this information is contained in the exemplary source code that is shown in FIGS. 33, 33A and 33B. By way of example, the global variables have a default value of "1" as is indicated at line 3310 (FIG. 33), unless some other value has been specified by the circuit designer. Other values can be applied to any of the global variables to customize a property form as will be shown. Therefore, there is no need to save global variables. Thus, the statement "dontSave", shown on line 3315 (FIG. 33) of the exemplary source code, is set to true ("t") which indicates that the parameter data for global variables are not saved. Note also, that for the library cdf parameters, such as "gateSize", include a radio type selection, as has been entered on line 3325 (FIG. 33). This permits selection of one of several choices, which for gateSize are the operating modes "N", "N,P" and "Explicit" as is indicated in line 3326, for example.

Steps 1508-1510 create the library cdf parameter "gateSize" for each logic gate. The default value is N mode in the exemplary embodiment. Steps 1512 and 1510 create the library cdf parameter "m" for each logic gate. The default value for parameter "m" is "1" in the exemplary embodiment. Steps 1516 and 1510 create the library cdf parameter "toolFilter" for each logic gate. The default value for parameter "toolFilter" is " " which, in the exemplary embodiment, represents that no tool filter has been selected. Steps 1518 and 1510 create the library cdf parameters "bnPLib" and "bnNLib" for each logic gate. Steps 1520 and 1510 create the library cdf parameter "paramX" and Steps 1522 and 1510 create the library cdf parameter "paramY". The choices for values for these parameters are contained in a list ₋₋ MS₋₋ CDF₋₋ POWER₋₋ LIST which includes "vpp|" and "vcc|" in the exemplary embodiment, and a list ₋₋ MS₋₋ CDF₋₋ GROUND₋₋ LIST which includes "vbb|" and "gnd|" in the exemplary embodiment. The default values vpp| and vbb| for parameters "bnPLib" and "bnNLib", respectively, are obtained from the lists ₋₋ MS₋₋ CDF₋₋ POWER₋₋ LIST and ₋₋ MS₋₋ CDF₋₋ GROUND₋₋ LIST. The parameter data created by these procedures is stored in the library cdf database 936.

After the foregoing procedures have been carried out, the parameter databases provided by the gate cdf parameter database 935 and the library cdf database 936 provide sufficient data for generating proper property forms for all of the logic gates in the library slib 1030 and for all three operating modes.

Schematic Create Engine

FIG. 16 is a block diagram of a schematic create engine 1605 for use in creating circuit schematics and which produces dynamic property forms in accordance with the invention using the gate cdf database 935, the library cdf database 936, and data stored in the user level parameter data storage 937. The schematic create engine 1605 includes a conventional circuit schematic create driver 1610 and a form displayer 1620. The schematic create engine also includes a form transformer 1615 and a database compactor 1616 which are provided by the invention. By way of example, the schematic create driver 1610 can be the DF2 schematic creation programs commercially available from Cadence Design Systems, Inc., San Jose, Calif. The form displayer 1620 supplies to the schematic create driver 1610 user-supplied functions which include the function schHiObjProperty(), which produces the display forms. One suitable form displayer is commercially available from Cadence Design Systems, Inc. The form transformer 1615 supplies to the schematic create driver 1610 user-supplied functions which include functions "MScdfGateIP()" and "MScdfGateModeCB()". The form transformer 1615 accesses the gate cdf database 935, the library cdf database 936 and the data in the user level data storage 937 to obtain parameter data for use in producing property forms and changing the forms. The database compactor 1616 supplies to the schematic create driver 1610 a user-supplied function "MScdfGateDP()" which compacts the data produced by user entry and the form transformer 1615.

The form create engine 1605 has associated therewith the user design library 1630 and a user schematic database 1638, which is a sub-database of the user library 1630. The user library 1630 contains design data for schematics designed by a circuit designer. The user schematic database 1638 contains for a plurality of instances or objects for schematics. An object database 1635, which is a sub-database of the user schematic 1638, stores parameter data for the current instance.

The schematic create driver 1610, the form transformer 1615, the database compactor 1616 and the form displayer 1620 can be software programs residing in computer system 905 (FIG. 9), or any other suitable media or computer program product that is capable of providing a computer readable program code. In one embodiment, schematic create driver 1610 and the user-supplied functions which comprise the form transformer 1615, the database compactor 1616 and the form displayer 1620 are written in SKILL code, a computer language provided by Cadence Design Systems, Inc., San Jose, Calif. In other embodiments, other computer languages, such as C++, Pascal, and SmallTalk computer languages can be used as well.

Schematic Creation

FIG. 17 is a process flow chart illustrating the steps taken by the schematic create engine 1605 in creating a property form for a design schematic wherein the property forms that are required are produced using the gate cdf database 935 and the library cdf database 936 and the user level stored in the user level data storage 937. In one embodiment, the schematic is created by a CAD system, using a circuit schematic design tool, such as the referenced Cadence DF2 schematic design tool.

Referring to FIGS. 9, 16 and 17, initially, the schematic design tool 1605 is logged in at step 1702. Step 1703 loads the database which, for example, includes the form transformer 1615, the database compactor 1616 and the form displayer 1620, and parameter data contained in the gate cdf database 935 and the library cdf database 936 that have been created by the procedure MScdfGateCreate as described above with reference to FIG. 11. Step 1704 reads the central text file 939 ".simrc" to obtain any cdf parameter and/or global variable customizing values that are stored in the central text file. This information is stored in temporary memory, such as miscellaneous storage 940, to be accessible.

Digressing, each library cdf parameter that is defined in the central text file can be customized to customize the form display. To customize the form display, the circuit designer needs to edit the central text file 939 to enter values for any user-defined library cdf parameters. Values for the global variables NDEFW, NDEFL, PDEFL and PNR also can be entered into the central text file 939 for use in producing numerical displays of default expressions. The global variables are used by callback procedure "MScdfGateCB()" to display numerical values for the default expressions whenever a change in mode occurs, as will be described. However, the global variables are only used in evaluating the default expressions, such as iPar("NDEFW"), and are not used to customize the form.

In addition, gate level cdf parameters can be customized by the procedure "MScdfGateIP()", providing another level of customization. In the exemplary embodiment, to customize the form display, the circuit designer can use an interface such as the Cadence Command Interpreter Window (CIW) that is provided as part of the Cadence DF2 schematic design programs. CIW is the very first window to appear when logging into a DF2 schematic design session. The CIW allows the user to open the design window or other windows and can execute Cadence commands, such as the command to load the central text file ".simrc" (step 1704). Moreover, the CIW displays command prompts or error messages and allows the user to quit out of the DF2 schematic design programs.

The CIW allows the user to enter command lines such as Wn=23, or bnN="gnd|" to customize default values for the gate cdf parameters. The user types a command line like Wn="23" and presses the "Return" key on the computer keyboard to enter the command. This is done in the CIW which displays a line box for user entry. The customized gate cdf parameter data is stored in miscellaneous data storage 940. It doesn't matter if command lines such as Wn="23" are entered before or after MScdfLibCreateUserParam() has been run because gate cdf parameters are a separate set of cdf parameters from the set of library cdf parameters. However, for library cdf parameters like NDEFW, bnPLib, toolFilter, and etc, which can be customized in the central text file, customizing values must be entered into the central text file .simrc 939 before the central text file is loaded at step 1704, and before the library slib 1030 is opened (step 1705). The procedure "MScdfGateIP()" uses the customized default values stored in temporary memory by CIW for customizing the form display.

Referring again to FIG. 17, step 1705 opens libraries, including the standard library 1030 and the user design library 1630, and triggers the procedure "MScdfLibCreateUserParam()", block 1706 which creates "user" level cdf parameter data for property forms that are used in designing a circuit schematic. The user level parameter data that is created is stored in the user level data storage 937 (FIG. 10) which is provided to the form transformer 1615 as shown in FIG. 16. The property forms are customized as to some or all of the default settings for library cdf parameters that are displayed on the property forms. The user level parameter data is dynamic and is not saved when the schematic design session is logged out. The fact that this user level parameter data is not saved provides a handle that allows the circuit designer to customize any or all of the library cdf parameters "m", "toolFilter", "gateSize","bnPLib", "briNLib", "paramX", and "paramY". A process flow chart for procedure "MScdfLibCreateUserParam( )" is given in FIG. 18 and illustrates how the form transformer 1615, using parameter values stored in the central text file 939, updates the library cdf parameters that are read from the library cdf database 936 in producing property forms.

The procedure "MScdfLibCreateUserParam()" is similar to the procedure "MScdfLibCreateBaseParam()", but differs in that the cdf parameters that are created have specific default values that are established by entering default parameter values into the central text file 939. The procedure MScdfLibCreateUserParam() creates only those library cdf parameters being customized with new default values in the central text file. These values provide new default values which are used rather than the default values that are produced by the procedure "MScdfLibCreateBaseParam()". The cdf parameters created by the procedure "MScdfLibCreateUserParam()" are referred to as user-level cdf parameters.

The procedure "MScdfLibCreateUserParam()" accesses the data read from the central text file 939 and, for each of the global variables and each of the library cdf parameters of the parameter group ₋₋ MS₋₋ CDF₋₋ LIB₋₋ PARAM₋₋ ALL, that are defined in the gate cdf database 935 and the library cdf database 936, creates a user-level cdf parameter. Each user-level cdf parameter that is created has the parameter value that is stored in the central text file 939, rather than the default value that is provided for the base level cdf parameters. These customized "user-level" cdf parameters, that are created by the procedure "MScdfLibCreateUserParam()" are stored in the user level parameter data storage 937.

Referring to FIG. 18, the procedure "MScdfLibCreateUserParam()" starts at step 1802. Steps 1804-1806 determine if data is contained in the user-level cdf parameter data storage 937 and if so, deletes the user-level cdf parameter data. Any user-level cdf parameters that were previously created and stored in the user-level cdf parameter database are deleted because steps 1808-1814 of the procedure create all of the user-level cdf parameters that are to be customized. Any library cdf parameters that are not customized are obtained from the library cdf database 936.

Steps 1808-1814 create, one at a time, those ones of the cdf parameters,"m" ,"gateSize", "toolFilter", "bnPLib", "bnNLib", "paramX" and "paramY", that are to be customized by calling the procedure "MScdfLibCreateParam()". Step 1810 accesses the user-defined parameter data read from the central text file 939 to determine if the cdf parameter that is being processed is defined in the central text file. It is pointed out that the value stored in the central text file can be a number value or a string value. If the parameter is defined in the central text file, step 1812 finds the value for the parameter. At step 1814, the procedure "MScdfLibCreateParam()" is run to replace the default value with the customizing value as the parameter is created. Step 1814 saves the user-level cdf parameter in the user cdf database 937 and the procedure advances to step 1816 to obtain the next parameter. If step 1810 determines that the library cdf parameter is not defined in the central text file, the procedure jumps to step 1816 to obtain the next parameter. Any cdf parameter that is not defined in the central text file is not created by the procedure. Rather, the default value for such parameter is determined from the base level definition. Thus, if a circuit designer has no preferences, the library cdf parameter values used are those that are created by the procedure "MScdfLibCreateBaseParam()" and the parameter values are obtained from the library cdf database 936. When step 1816 determines that all of the cdf parameters have been processed, control is returned to the schematic create driver 1610.

Referring again to FIG. 17, a schematic is opened at step 1708. Then, at step 1710, the circuit designer places a gate instance on the schematic. In response to placing an instance on the schematic, initialization step 1712 obtains cdf parameter data from the user-level cdf parameter data storage 937 for the library parameters that are to be customized and cdf parameter data from the library cdf database 936 for any library cdf parameters that are not being customized, and obtains cdf parameter data from the gate cdf database 935 for all the gate parameters. In addition, step 1712 calls the initialization procedure "MScdfGateIP()", block 1714, of the form transformer 1615, for initializing an Add Component form that is produced in response to placing an instance on the schematic. An example of an Add Component form is illustrated in FIG. 20.

The procedure "MScdfGateIP()" is called each time that an instance is placed on the schematic to customize the form display as to library cdf parameters and gate cdf parameters for that instance. For customization of library cdf parameters, the procedure "MScdfGateIP()" provides an automatic customization of the form display using the values for the user-defined parameters that have been entered into the central text file 939 and transferred to the library user database 937 by the procedure "MScdfLibCreateUserParam()". For customization of gate cdf parameters, such as parameter Wn="23", these parameters are customized on the fly using the CIW, on the "Add Component" form which is called by a Cadence create instance procedure referred to as the schHiCreateInst() procedure when a new instance is to be added displays the customized value. If the form is closed, the user still gets the same customized instance of Wn="23" when adding another new instance by the schHiCreateInst() procedure. The customization eliminates the need to select various operating conditions and gate cdf parameters so that the same information does not have to be re-entered every time a new gate instance is placed. Without this gate level customization, users have to manually modify parameters, such as Wn, for every placement.

The procedure "MScdfGateIP()" allows the circuit designer to customize parameter default values, thereby customizing the property forms that are displayed during the creation of a circuit schematic. FIG. 19 is a process flow chart illustrating how the initialization procedure "MScdfGateIP()" of the form transformer customizes an Add Component form so that the property forms produced in connection with the creation of a circuit schematic are customized.

Digressing, FIG. 20 illustrates an Add Component form 2000 that is displayed in response to a gate instance being placed on the schematic. In the exemplary embodiment, the parameter values that can be specified by the circuit designer include the default mode for gateSize (i.e., mode N, NP, Explicit) 2002, local multiplier "m" 2004, toolFilter (Ivs, hsp, all) 2006; the bulk potential bnPLib (vpp| or vcc|) 2010 for PMOS devices; and the bulk potential bnNLib (vbb| or gnd|) 2012 for NMOS devices. The procedure "GateModeIP()" customizes the display of the gate cdf parameters, such as drive strength (Wn) 2014, which are created using the Gate Create procedure and are stored in the database 935. In addition, the procedure "GateModeIP()" customizes the Add Component form as to the display of the parameters bnP and bnN because these parameters are more likely to be changed by the circuit designer. The procedure customizes these parameters each time an instance is placed on a schematic.

The bulk node potential parameters bnPLib and bnNLib are library level parameters which are created by the procedure "MS₋₋ cdfLibCreateParam()". The library cdf parameters bnPLIb and bnNLib have default values and are stored in the library cdf parameter database. The bulk node potential parameters are also defined as parameters bnP and bnN, which are gate level parameters which are created by the procedure "MScdfGateCreate". The gate cdf parameters bnP and bnN can have customized values or default values and are stored in the object database for the instance to which the parameters apply. Also, the bulk node potential parameters that are being displayed on a property form are defined as bnPDisplay and bnNDisplay with the values for the parameters bnP and bnN being obtained from the object property database. The purpose of the multiple definition of the bulk node potentials is to provide flexibility for the circuit designer in selecting bulk node potentials for the gates of circuit schematics being designed by providing a flexible default condition for these parameters.

The parameters bnP and bnN are selectable using radio type selectors rather than data boxes that are used for the other gate cdf parameters. This allows the user to see the actual value for the bulk node potentials rather than a default expression, such as "iPar("bnPLib")", as is displayed for the other gate cdf parameters during the initialization procedures. Moreover, the power and ground lists contained in the data structure 934c can be altered to include additional choices for the parameters bnP and bnN without affecting the form and schematic creation procedures.

The procedure "MS₋₋ cdfLibCreateUserParam()" determines if the parameters bnPLib and bnNLib are defined in the central text file and if so, customizes these parameters. However, no change is made in the library cdf parameter database. During initialization, the procedure "MScdfGateIP( )" accesses the customizing data read from the central text file and customizes the parameters bnP and bnN, if customizing values have been entered into the central text file. This information is used to customize the display of these parameters. If customizing values have not been entered into the central text file for these parameters, the parameters are displayed as the default values of bnNLib and bnPLib stored in the library cdf parameter database 936.

In producing an Add Component form, the schematic create engine 1605 (FIG. 16) accesses the library database 1030 to obtain a new schematic. In addition, the schematic create engine accesses the library cdf parameter database contained in database 936 to obtain those parameters needed to display the Add Component form and which are not available from the library slib 1030. Also, user level data in the user-level parameter data storage 937 is accessed to obtain any customized parameter values that have been produced by the procedure "MScdfLibCreateUserParam()".

Producing the Add Component form includes displaying default values for the cdf parameters, substituting customizing values for the default values depending upon what data is stored in the central text file. In the exemplary embodiment, the Add Component form 2000 displays default values that are obtained from the library cdf parameter database. Thus, N mode is the default mode for the procedure as is indicated at 2002 for gateSize on the form 2000. The multiplier "m" is the default value of "1" as is indicated at 2004. No tool filter is selected as is indicated at 2006. In addition, the drive strength Wn (2014), as displayed, is represented by the default expression "iPar("NDEFW")" shown in data box 2008 if the parameter is not customized. Also, the PMOS bulk potential is vpp| as is indicated at 2010 and the NMOS bulk potential is vbb| as is indicated at 2012.

Referring to FIGS. 19 and 20, the procedure "GateModeIP()" starts at step 1902. Step 1903 determines if an Edit Object Property form is being displayed. It is pointed out that the Add Component form, such as Add Component form 2000, is produced before the Edit Object Properties form. Accordingly, the first time that the procedure"GateModeIP()" is run for a given instance, the procedure continues to step 1904 which determines whether or not an Add Component form is being displayed. If step 1904 confirms that the form being displayed is an Add Component form, the procedure continues to step 1906. Otherwise, step 1905 returns control to the schematic create driver 1610.

When step 1904 determines that an Add Component form is being created, then, steps 1906-1922 process, in sequence, each of the cdf parameters, including the library cdf parameters, the global variables, and the gate cdf parameters. As each cdf parameter is obtained at step 1906, step 1908 determines if the parameter being processed is contained in the group ₋₋ MS₋₋ CDF₋₋ LIB₋₋ PARAM₋₋ ALL, i.e., is one of the library cdf parameters or one of the global variables. The form display default values for the parameters in this group have already been customized using the procedure "MScdfLibCreateUserParam()". Accordingly, for each cdf parameter that is contained in the group MS₋₋ CDF₋₋ LIB₋₋ PARAM₋₋ ALL, the procedure jumps to step 1924. Step 1924 determines if there is another cdf parameter to be processed. If so, the procedure returns to step 1906 to process the next cdf parameter. The gate cdf parameters are not contained in the group ₋₋ MS₋₋ CDF₋₋ LIB₋₋ PARAM₋₋ ALL. Examples of gate cdf parameters for which default settings can be changed include drive strength Wp, Lp, Ln, bnP, bnN, wpA, wnA, lpA, lnA, etc. The gate cdf parameters are produced by the procedure MS₋₋ cdfGateCreate and the parameter data is stored in the gate cdf parameter database 935. The values for these parameters are stored in the object database 1635 for the instance to which the values apply. In addition to the automatic customization provided by the procedure "MScdfGateIP()", the circuit designer can manually customize the default settings for the user-defined parameters that are being displayed on the Add Component form.

Step 1910 determines if the cdf parameter being processed is either one of the cdf gate parameters bnP or bnN. If so, step 1912 determines if the cdf gate parameter bnP (or bnN) is defined in CIW. If so, step 1914 customizes the bnPDisplay (or bnNDisplay) to correspond to the value stored in CIW. The customized value is stored in the object database 1635 when the circuit designer places the current instance. The process continues to step 1924 which determines if there are any more cdf parameters to be processed and if so, returns to step 1906. If step 1912 determines that the parameter is not defined in CIW, then step 1916 updates the parameter bnPDisplay (or bnNDisplay) to have the default value stored in the library cdf parameter database. In updating the parameter bnPDisplay or bnNDisplay, the procedure obtains the value for the parameter from the instance database if the parameter has been customized by step 1914 or from the parameter database, i.e., the default value, if the parameter has not been customized. The parameters bnPDisplay and bnNDisplay are stored in temporary storage and are not saved when a form is closed. Accordingly, values for these parameters are updated when an Add Component form or a property form is brought up.

The process continues to step 1924 which determines if there are any more cdf parameters to be processed and if so, returns to step 1906. If step 1910 determines that the cdf parameter is neither bnP nor bnN, the procedure continues to step 1918 which determines whether the cdf parameter is defined in CIW. For each gate cdf parameter, other than parameters bnP and bnN, that is defined in the database, step 1920 finds the string value or the numerical value for the parameter, and step 1922 uses the value to customize these gate cdf parameters for use in providing numerical values for display when the procedure MScdfGateCB() is run. If step 1918 determines that the cdf gate parameter is not defined in CIW, then the process continues to step 1924 which determines if there are any more cdf parameters to be processed and if so, returns to step 1906. When step 1924 determines that there are no further cdf parameters to process, step 1926 returns control to the schematic create driver 1610.

Any one of the modes N, NP or Explicit can be selected as the default mode and appropriate default expressions are displayed on the Add Component form that is brought up, depending upon the default mode that has been selected. For example, when NP mode is selected as the default mode, the default expressions for parameters Wp, Wn, Lp and Ln are displayed. Also, when Explicit mode is selected, in addition to the default expressions for parameters Wp, Wn, Lp and Ln, default expressions are displayed for parameters wp, wn, lp, and in for each of the devices that comprise the logic gate that is placed on the schematic. Likewise, the settings for drive strength, tool filter and bulk potentials can be changed on the Add Component form.

It is pointed out that when the Add Component form has been brought up, even if customizing parameter values have not been entered into CIW, the circuit designer can manually change the settings for the multiplier, the operating mode, the tool filter, drive strength or bulk potentials, as desired. The information that has been entered onto the Add Component form manually is not saved in the library cdf parameter database that is used to create the forms when the Add Component form is closed. However, the circuit designer can save information entered onto the form by clicking the mouse prior to closing the form. This causes the entered information to be saved to the object property database for the current instance. Thus, unless the circuit designer saves the information to the object database, upon reopening of the design library, the form displays the default values that have been created through procedures MS₋₋ LibCreateBaseParam() and MS₋₋ cdfLibCreateUserParam().

Referring to FIG. 17, when customization of the Add Component form is done and any changes in the default settings have been entered onto the form, the circuit designer places the gate instance using one of the input devices 925 (FIG. 9), such as by a click of the mouse. This causes the customized form display information to be stored in the object database 1635 of the user schematic database 1638 that is created for the current instance. In addition, at step 1713, a procedure "MScdfGateDP()" of the database compactor 1616 is run to update the object database 1635. The manner in which the procedure "MScdfGateDP()" updates the schematic database is described below with reference to FIG. 22. Then, the circuit designer closes the Add Component form 2000 by selecting "Cancel" 407 on the form 2000. The customized parameter settings that have been chosen by the designer are established for future access. When customization of the Add Component form is complete, the initialization process (step 1712) is complete and step 1918 returns control to the schematic create driver 1610.

Subsequently, as each instance is placed on the schematic, a procedure "schHiObjectProperty()" of the form displayer 1620 is called at step 1716 The procedure "schHiObjectProperty()" enables the circuit designer to change any property for an instance. The procedure "schHiObjectProperty()" produces the Edit Object Properties form, hereinafter "property form", for the selected instance. The property form that is brought up is customized in correspondence with the customization of the Add Component form 2000. The procedure "schHiObjectProperty()" accesses the object data contained in the object database 1635 to get the saved property parameter values for the library cdf parameters for the current instance. The procedure "schHiObjectProperty()" also runs the procedure MScdfGateIP(), as represented by the dashed line 1715. However, as is illustrated in FIG. 19, when step 1903 determines that an Edit Object Properties form is being created, the procedure branches to step 1928 which updates the cdf parameters bnPDisplay and bnNDisplay for the component bulk connections. Step 1930 then returns control to the schematic create driver 1610.

Referring to FIG. 17, because N mode (step 1718) is the default mode in the example, the initial property form that is displayed on the screen 960 of the display unit (FIG. 9) corresponds to property form 2400 that is shown in FIG. 24. Note that the drive strength is expressed as "iPar(NDEFW)" as indicated at 2402. The circuit designer can specify any value for "NDEFW" and, for example, initially the value is selected to be "10" and this value is displayed on the property form, as for property form 400 which is shown in FIG. 4. When "Apply" 405 is selected, the parameter value is stored in the object database 1635.

Whenever "gateSize" is changed on the active property form at steps 1718, 1722 or 1726 (FIG. 17), a procedure "MScdfGateModeCB()" is called by steps 1720 and 1724, for example. The procedure "MScdfGateModeCB()" updates all of the parameter values that are being displayed on the active property form, including calculating numerical values for the parameters based upon default values if default values exist, as will be described. In addition, the schematic create engine 1605 causes creation of the labels, data boxes, etc. that are required for the mode that has been selected. The information needed to display the appropriate prompts, default expressions, and data boxes is obtained from the gate cdf parameter database 935, the cdf library parameter database 936 and the user level parameter data storage 937. The procedure MS₋₋ cdfGateCreate, the source code of which is provided in FIGS. 30A, 30B and 30C, includes query functions such as "?display" (see for example, lines 3013 and 3024 in FIG. 30A) that are interpreted by the Cadence driver for displaying the appropriate form as a function of the mode that is selected. That is, parameter labels, data boxes, and numerical default values are added to the property form when changing from N mode to NP or Explicit mode (or from NP to Explicit) or deleted from the property form when changing from Explicit mode to NP or N mode (or NP mode to N mode). FIG. 21 is a process flow chart illustrating how the form transformer 1615 updates parameter values being displayed on a property form.

Referring to FIG. 21, the procedure "MScdfGateModeCB()" updates all of the parameter values on the active property form whenever the gateSize is changed. The procedure begins at step 2102, and step 2103 determines if the Add Component form is being displayed. If so, control is returned to the schematic design driver 1610 because the procedure "MScdfGateModeCB()" is not run for the Add Component form. If step 2103 determines that the Add Component form is not being displayed, then, step 2104 determines which mode is currently selected. For the N mode, step 2106 calculates the value for Wn. Step 2107 returns control to the schematic create driver 1610.

For NP mode, steps 2108-2110 determine, for each of the parameters "Wn", "Wp", "Lp" and "Ln", if the parameter displayed by Cadence form displayer 1620 is an expression-type string whose value cannot be determined by evaluating the string. If so, step 2112 uses a Cadence SKILL command cdsParam() to calculate the corresponding value of the expression by using the global variables which have been converted into library cdf parameters by MScdfLibCreateUserParam() as described above. See, for example, the property form 2500 shown in FIG. 25 where a non-default value of "10" is displayed for parameter Wn and numerical default values are displayed for parameters Wp, Lp and Ln. The value for parameter Wp is "15" which is obtained by evaluating the default expression "iPar("PNR")*iPar("Wn")", where "NDEFW" is equal to "10" and "PNR" is equal to 1.5. The values for Lp and Ln are obtained by evaluating respective default expressions "iPar("PDEFL")" and "iPar("NDEFL")". When all four parameters have been processed, as determined by step 2113, control is returned to the schematic create driver 1610.

Similarly, for Explicit mode, steps 2114-2116 determine, for each of the parameters wpA, wnA, lpA, lnA, wpB, wnB, lpB, lnB, etc., if the parameter displayed by Cadence form displayer 1620 is an expression-type string whose value cannot be determined by evaluating the string. If so, step 2118 uses Cadence SKILL command cdsParam() to calculate the corresponding value of the expression by using the global variables which have been converted into library cdf parameters by MScdfLibCreateUserParam() as described above. The property form 2800, shown in FIG. 28, shows numerical values displayed for the parameters wpA, wnA, lpA, lnA, wpB, wnB, lpB, lnB, etc. Step 2120 determines when all of the parameters have been processed and then returns control to the schematic create driver 1610.

Referring again to FIG. 17, also, when "Apply" 407 (FIG. 25) is selected, the procedure advances to step 1728 which calls a procedure "MScdfGateDP()" of the database compactor 1616 to update the schematic object database 1635. Procedure "MScdfGateDP()" includes procedures that conform the values of parameters, such as "Wn", "Wp", "Ln" and "Lp", stored in the schematic object database 1635 to the current state of the active property form and saves, or deletes, size and netlist properties when necessary. FIG. 22 is a process flow chart illustrating how the database compactor 1616 screens parameter default values and purges parameters when parameter data has been saved to the object database by the Cadence "Apply" function.

Referring now to FIG. 22, the procedure "MScdfGateDP()" of the database compactor 1616 includes procedures "MS₋₋ cdfGateVerifyN()" 2206, "MS₋₋ cdfGateVerifyNP()" 2226, "MS cdfGateVerifyExplicit()" 2242, and "MS₋₋ cdfGateVerifyBulk()" 2260, the functions of which are to screen out parameter values that are equal to default values as will be described. The procedure "MScdfGateDP()" also includes the procedure "MS₋₋ cdfGatePurgeNP()" 2214 and the procedure "MS₋₋ cdfGatePurgeExplicit()" 2220, the functions of which are to delete parameters, absolutely, in response to a change in mode, as will be described. It is pointed out that although the procedure "MS₋₋ cdfGatePurgeNP()" 2214 and the procedure "MS₋₋ cdfGatePurgeExplicit()" 2220 are carried out whenever gateSize is changed to the N mode or the NP mode, these procedures are effective only when changing from Explicit mode to NP mode or N mode, or from NP mode to N mode because the function of these procedures is to delete parameters that are not to be used in the new mode selected.

The procedure "MScdfGateDP()" includes a separate branch for each of the modes. The mode that is currently selected is determined by step 2204. For N mode, the procedures "MS₋₋ cdfGateVerifyN()" 2206, "MS₋₋ cdfGatePurgeNP()" 2214 and "MS₋₋ cdfGatePurgeExplicit()" 2220 are preformed. The procedure "MS₋₋ cdfGateVerifyN()" 2206 screens out parameter values that are equal to default values by comparing the value of each parameter with the default expression for the parameter. The procedure "MS₋₋ cdfGateVerifyN()" 2206 begins at step 2208 which stores the default expression iPar("NDEFW") as a temporary variable, which is identified as "paramX".

After "paramX" has been stored, at step 2210, the expression "paramX" is evaluated using a Cadence SKILL command cdsParam(), using default values stored in the gate cdf parameter database and compares "paramX" with parameter Wn that is being displayed on the active property form to determine if the value of the parameter Wn being displayed is the default value. It is pointed out, Wn can be an expression, iPar(NDEFW) or a numerical value, such as "10" in the example. If the value of parameter Wn is "5" which is equal to the corresponding default expression iPar("NDEFW") saved in "paramX" in this case, step 2212 deletes the parameter value for Wn from the object database 1635 because the default value can be obtained from the library cdf parameter database when required. However, if the value of parameter Wn is not the default value, the currently active value of the parameter Wn is saved in the schematic object database 1635 for the current instance.

The procedure "MScdfGateDP()" continues to step 2216 and executes procedure "MS₋₋ cdfGatePurgeNP()" 2214. Steps 2216-2219 delete any parameter values for Wp, Lp, and Ln that have been stored in the object database 1635 for each of these parameters because these parameters are not displayed for N mode. This procedure is executed when changing from NP mode to N mode, or from the Explicit mode to N mode. The procedure continues to step 2222 which executes procedure "MS₋₋ cdfGatePurgeExplicit()" 2220. Steps 2222-2225 delete the parameter values wpA, wnA, lpA, and lnA, etc., for each of the parameters wp, wn, lp, and ln because these parameters are not displayed for N mode. This procedure is executed when changing from Explicit mode to N mode, for example.

For NP mode, the procedure "MS₋₋ cdfGateVerifyNP()" 2226 and the procedure "MS₋₋ cdfGatePurgeExplicit()" 2220 are performed. The procedure "MS₋₋ cdfGateVerifyNP()" 2226 is similar to procedure "MS₋₋ cdfGateVerifyN()" 2206, except that the procedure is carried out in sequence for each of the parameters "Wp", "Wn", "Lp" and "Ln". Whenever the procedure "MS₋₋ cdfGateVerifyNP()" is called, the default expression for each parameter of the set of parameters "Wp", "Wn", "Lp" and "Ln" that is to be verified is stored as "paramX" for use in verifying that the value of the parameters being verified match the corresponding default value. The parameters of a set of parameters, such as the parameter set Wp Wn, Lp and Ln, are verified one after another for each parameter of the set. The parameters are verified using Cadence SKILL command cdsParam() to evaluate the appropriate default expression, stored as "paramX", and comparing the numerical value with the parameter value that has been entered into the object database. The procedure "MS₋₋ cdfGatePurgeExplicit()" 2220 has been described above.

For Explicit mode, the procedure "MS₋₋ cdfGateVerifyExplicit()" 2242 is performed. Procedure "MS₋₋ cdfGateVerifyExplicit()" 2242 is similar to procedure "MS₋₋ cdfGateVerifyNP()" 2226, except that the procedure is carried out in sequence for each of the parameters of a set of device parameters. For the exemplary logic gate, the set of parameters includes the parameters wpA, wnA, lpA, lnA, wpB, wnB, lpB, lnB. The parameters processed are a function of the logic gate that has been placed on the schematic.

The procedure "MScdfGateDP()" also calls the procedure "MS₋₋ cdfVerifyBulk()" 2260 to screen out values for the bulk node connection parameters "bnP" and "bnN" that are equal to default values. The procedure "MS₋₋ cdfVerifyBulk()" is similar to the procedure "MS₋₋ cdfGateVerifyNP()" and screens out default values by comparing the value of each of the gate cdf parameters "bnP" and "bnN" that is being displayed with the default expression for the parameter. A process flow chart for the procedure "MS₋₋ cdfVerifyBulk()" is given in FIG. 23.

Referring to FIG. 23, the procedure "MS₋₋ cdfVerifyBulk()" begins at step 2302. Steps 2304-2312 process the two gate cdf parameters bnP and bnN in sequence. When parameter bnP is being processed, step 2306 stores the default expression iPar("bnPLib") as a temporary variable that is identified as "paramY". This temporary variable is used in verifying that the value of the parameter being verified matches the corresponding default value.

After "paramY" has been stored, then at step 2308, the expression "paramY" is evaluated using Cadence SKILL command cdsParam() and compared "paramY" with the display value for the parameter "bnP" to determine if the value of the parameter "bnP" that is being displayed is the default value. It is pointed out the expression "iPar(bnPLib)" is evaluated as the default value "vcc|", in the example. If the parameter bnP is the default value, and thus is equal to "paramY", step 2310 deletes the parameter value for bnP from the object database 1635 because the default value can be obtained from the library cdf parameter database when required. However, if the value of parameter bnP is not the default value, the currently active value of the parameter bnP is maintained in the schematic object database 1635 for the current instance. Step 2312 then returns to step 2324 and a similar process is carried out for the parameter "bnN" using the default expression "iPar("bnNLib")". When both of the parameters bnP and bnN have been processed, step 2313 deletes "paramX" and "paramY". Then, step 2314 returns control to the schematic create engine 1605.

Referring again to FIG. 17, from step 1728, further changes can be made in parameters of the current instance, as represented by the step 1732 which is labeled "Modify". Step 1732 represents re-entering one of the steps 1718, 1722 or 1724, and the function "MScdfGateModeCB()" updates the property form, depending on the mode selected. Alternatively, new parameter data can be entered into the active property form without change in operating mode. The object database 1635 is updated when "Apply" is selected.

If no further changes are made, control is returned to the schematic create driver 1610, at step 1710, in response to the circuit designer closing the active property form by selecting "Cancel" 407 (FIG. 29). The procedure is reentered if the circuit designer reopens a previously created property form or places a further gate instance on the schematic. This results in the creation of a further property form by steps 1712-1716, and the selection of the default mode, N mode, at which time, the circuit designer can enter parameter data for the new instance, or select a different mode, as desired, following the flow of steps 1718-1732. It is pointed out that the initialization procedure "MScdfGateIP()"is called each time a new instance is placed on the schematic by the circuit designer. The procedure "schHiObjectProperty()" is called when a previously created form is reopened, and this procedure also calls the procedure "MScdfGateIP()".

In summary, the procedures "MScdfGateModeCB()" and "MScdfGateDP()" provide dynamic form display. In response to a change in mode, the procedure "MScdfGateModeCB()" automatically transforms expressions into numerical values for gate cdf parameters, such as Wn, Wp, Ln and Lp. When the user clicks the Cadence "Apply" button 405 (FIG. 4, for example) all numerical data displayed on the form is saved in the object database. However, the procedure "MScdfGateDP()" deletes from the object database any gate cdf parameter values that are equivalent to their corresponding default expressions. Thus, this dynamic property form generation provides a convenient function that allows a circuit designer to see calculated final numerical values, instead of raw expressions, for gate cdf parameters whenever a mode change is effected. In addition, this dynamic property form generation maintains the object database compact by deleting parameters parameters whose values are equivalent to their corresponding default expressions after data has been saved to the object database.

The following description illustrates the dynamic property form generation according to the invention using the gate cdf database 935 and the library cdf parameter database 936. In the example, it is assumed that no customizing parameter values have been entered into the central text file 939 for the library cdf parameters, "gateSize", "m", "toolFilter", "bnPLib" and "bnNLib". Thus, the Add Component form (FIG. 20) that is produced displays the default mode as being mode N as indicated at 2002; the local multiplier "m" as being "1" as indicated at 2004; the toolFilter as indicating none selected as indicated at 2006; the bulk potential bnPLib as being vpp| as indicated at 2010; and the bulk potential bnNLib as being vbb| 2012 as indicated at 2012.

As to the global variables NDEFW", "PNR", "NDEFL" and "PDEFL", the default values for these expressions can be changed by entering the appropriate data into the central text file. For example, a value of "5" has been entered into the central text file for global variable "NDEFW" and that a value of 1.5 has been entered into the central text file for global variable "PNR". Values of 1.5 have been entered for global variables "NDEFL" and "PDEFL" and are stored in the central text file.

Customization of the library level parameters in this manner provides for full form customization, including gateMode-triggered callback. However, because these are library level parameters, these default values will customize form displays for all of the instances placed into a schematic. To provide more flexibility, gate level parameters are customized on the fly using the Cadence Command Interpreter Window (CIW) and are stored in temporary memory. In the example, only gate cdf parameter Wn is customized in this manner. These default value(s) for parameters customized by CIW are used in producing numerical value displays until manually changed back to the library default values or another value. Such change can be made in placing any instance and without having to edit the central text file which would require either closing and reopening the library and reloading the central text file after changing the stored default values (steps 1704 and 1705) or reloading of the databases, such as by relogging in the schematic design programs. Neither of these methods is as convenient as using the CIW.

Referring to FIGS. 9, 16 and 17, step 1702 logs in the schematic create programs. Step 1703 loads the databases including the gate create formatters 934, the Gate Count data structure 934a, the Gate Stack data structure 934b, the data structure 934c, the form transformer 1615 and the compactor 1616. Step 1704 reads the central text file 939. At step 1705, the library slib 1030 is opened and the library cdf parameter database 936 is loaded. Also, the procedure "MScdfLibCreateUserParam()" is called to create a user level database 937 for use in customizing the form display.

Referring to FIG. 18, the procedure starts at step 1802. Steps 1804-1806 delete any data stored in the user level parameter data storage 937. Steps 1808-1814 process each parameter contained in group MS₋₋ CDF₋₋ LIB₋₋ PARAM₋₋ ALL to determine which of these parameters is defined in the central text file, and thus is to be customized. As has been indicated, this group of parameters includes the global variables "NDEFW", "PNR", "NDEFL" and "PDEFL" and the library cdf parameters "m", "gateSize", "toolFilter", "bnPLib", "bnNLib", "paramX" and "paramY". For global variable "NDEFW", a parameter value of "5" has been stored in the central text file and this data was read from the central text file by step 1703. Also, a value of 1.5 was read from the central text file for global variable "PNR", and values of 1.5 have been read for global variables "NDEFL" and "PDEFL".

Step 1808 processes parameter "NDEFW". Step 1810 accesses the parameter data for the parameter "NDEFW" and determines that this parameter is defined in the central text file. Accordingly, step 1812 finds the value for the parameter. Then, step 1814 calls the procedure MScdfLibCreateParam().

Referring to the process flow chart of FIG. 15 and to the source code for the procedure MScdfCreateLibParam() illustrated in FIG. 33, the procedure starts at step 1502 and step 1504 determines that the parameter "NDEFW" being processed is a global variable from the set MS₋₋ CDF₋₋ GLOBAL₋₋ VAR and step 1506 calls the procedure "cdfCreateParam()" which creates the parameter.

Step 1506 creates the parameter to have a default value of "5". Referring to FIG. 33 at line 3314, in creating the parameter, the value of "5" is used as the customized default value, rather than the default value of "1". Referring again to FIG. 18, the parameter data for the cdf parameter that has been created is stored in the user level parameter data storage 937 as user-level data. Step 1816 returns the procedure to step 1808 to process the next cdf parameter.

A similar process is carried out for global variable "PNR", resulting in the value "1.5" being substituted for the default value of 1. For the global variables "NDEFL" and "PDEFL", a value of 1.5 exists in the central text file and so, at step 1808, these parameters are created. For each of the library cdf parameters "m", "gateSize", "toolFilter", "bnPLib", "bnNLib", "paramX" and "paramY" a value does not exist in the central text file and so the default values defined by the procedure "MScdfLibCreateBaseParam()" are used. When all of the parameters contained in the group have been processed, the procedure is done and control is returned to the schematic create engine at step 1708.

At step 1708, a design schematic is opened. At step 1710, the circuit designer places an instance on the schematic, which, in the example, is assumed to be instance GNA0 of the NAND gate which is illustrated in FIG. 1. Step 1712 calls the initialization procedure "MScdfGateIP()".

Referring to FIGS. 19 and 20, the procedure "MScdfGateIP()" begins at step 1902. Step 1903 determines that a property form is not being created and step 1904 determines that an Add Component form, such as Add Component form 2000, is being created. Step 1906 receives the cdf parameters one at a time. For each of the global variables "NDEFW", "PNR", "PDEFL" and "NDEFL", and for each of the library cdf parameters, "m", "gateSize", "toolFilter", "bnPLib", "bnNLib", "paramX" and "paramY", step 1908 bypasses the form customizing steps 1910-1922 because form customizing information provided by these parameters has been done by the procedure "MScdfLibCreateUserParam()".

However, for each gate cdf parameter, such as gate cdf parameters bnP, bnN, Wn, Wp, Ln and Lp, for example, steps 1910-1922 customize the cdf parameter if a customizing value has been entered using the CIW. Thus, when step 1908 determines that the parameter being processed is not a global variable or a library cdf parameter, the procedure continues to step 1910 which determines whether the parameter being processed is bnP or bnN. If the parameter being processed is either one of these parameters, the procedure continues to step 1912. In the example, neither of these parameters is defined in CIW and so the procedure continues to step 1916 which updates the parameter bnPDisplay (and then parameter bnNDisplay) by obtaining the default values bnPLib (or bnNLib) from the library cdf parameter database if the parameter has not been customized, or from the object database 1635 if the parameter has been customized.

However, if a customizing value such as "gnd|" has been entered using the CIW, step 1912 determines that the parameter is defined in the CIW and so the procedure continues to step 1914 to customize the display parameter bnNDisplay. For example, the value displayed for the parameter bnN will be "gnd|" rather than the default value of "vbb|". In either case, the procedure continues to step 1924 which returns to step 1906 to process the next parameter.

When step 1908 determines that the parameter being processed is parameter Wn, at step 1910, the procedure continues to step 1918 which determines whether the parameter Wn is defined in CIW. If a value, such as Wn="23", has been entered using the CIW, step 1920 finds the value and 1922 causes the number "23" to be stored in temporary memory for use by the procedure MS₋₋ cdfGateModeCB(). In this case, the numerical value of "23" would be displayed on the Add Component form 2000 (FIG. 20) rather than the default expression "iPar("NDEFW")". However, in the present example, no customizing value for parameter Wn has been entered using the CIW and so the Add Component form displays the default expression for the parameter Wn.

When the gate parameters "Wp" "Lp" and "Ln" are processed, the step 1918 determines that these parameters are not defined in CIW and so these gate parameters are not customized.

When customization of the Add Component form has been completed and any changes in the default settings have been entered, the circuit designer places the gate instance using one of the input devices 925 (FIG. 9), such as by a click of the mouse. This causes the customized form display information to be stored in the object database portion of the schematic object database 1635 that is created for the current instance. In addition, at step 1713, the procedure "MScdfGateDP()" of the database compactor 1616 is run to update the schematic object database 1635. The manner in which the procedure "MScdfGateDP()" updates the schematic database has described above with reference to FIG. 22. In the example, the value for parameter Wn is a default value and so the value is not saved in the object database 1635. However, if a non-default value, such as "23", had been entered onto the Add Component form for the parameter Wn, using the CIW, the parameter would be saved in the object database.

Then, the circuit designer closes the Add Component form 2000 by selecting "Cancel" 407 on the form 2000. The customized parameter settings that have been chosen by the designer are established for future access. When customization of the Add Component form is complete, the initialization process (step 1712) is complete and step 1926 returns control to the schematic create driver 1610.

To illustrate the use of the property form created by the invention, it is assumed that the circuit designer selects a logic gate, such as NAND gate GNA0, and presses a "bind" key on the computer keyboard in the conventional manner, to initiate the object property editing function. This causes the procedure schHiObjectProperty()" to be called at step 1716, which in turn calls the procedure MScdfGateIP()". The procedure begins at step 1902 and step 1903 determines that the Edit Object Properties form is being produced. Accordingly, the procedure "MScdfGateIP()" steps directly to step 1928 which updates the parameters bnPDisplay and the bnNDisplay. Step 1930 returns control to the schematic create driver 1610.

The procedure "schHiObjectProperty()" displays the property form 2400 (FIG. 24). The information contained on property form 2400 corresponds to the information that has been entered onto the Add Component form. Thus, as can be seen, on the property form 2400, drive strength Wn is displayed in data box 2402 as the default expression "iPar("NDEFW")". If drive strength Wn had been customized using the CIW, the value, such as "23" would be displayed in data box 2402. No tool filter has been selected and this is indicated at 2404. N mode is the default mode as indicated at 2406. The bulk node potentials for PMOS and NMOS devices are vpp| and vbb|, respectively at 2410 and 2412.

In the example, it is assumed that the circuit designer enters a value "10" for the parameter drive strength Wn onto data box 2402 and then selects "Apply" 405 to store this parameter value in the schematic object database 1635.

In response to selection of "Apply", the procedure jumps to step 1728 and calls the procedure "MScdfGateDP()" to screen out the default values. Referring to FIG. 22, the procedure begins at step 2202. Step 2204 determines that N mode is active. Consequently, procedure "MScdfGateVerifyN()" 2206 is called, beginning at step 2208 which stores the default expression for Wn, namely "iPar(NDEFW)" as "paramX". At step 2210, a numerical value is calculated for "paramX" using Cadence SKILL command cdsParam(). In the example, the numerical value is "5". This value is compared with the value "10" for the parameter Wn that has been entered onto the active property form, and which just has been stored in the object database 1635 in response to selection of "Apply". Because the value of the parameter being displayed is not the default value, the parameter value for Wn is saved in the schematic object database 1635.

The flow continues to procedure "MScdfGatePurgeNP()" 2214, the function of which is to delete from the schematic object database 1635 parameter values for any parameters, such as Wp, Lp and Ln, that are not displayed in N mode. In the example, NP mode has not been selected previously and so none of these values has been entered onto the property form. The procedure continues to procedure "MScdfGatePurgeExplicit()" 2220, the function of which is to delete from the schematic object database 1635 parameter values for any parameters, such as wpA, wnA, etc. that are not displayed in N mode. Again, in the example, Explicit mode has not been selected and so values have not been entered onto the property form for parameters, such as wpA, wnA, etc. In the example, the property form now displayed corresponds to property form 400 (FIG. 4) wherein the parameter value for drive strength Wn is shown to be "10". Flow continues to step 2260 which runs the procedure MS₋₋ cdfVerifyBulk() to update the cdf parameters bnP and/or bnN.

Referring to FIG. 23, the procedure "MS₋₋ cdfVerifyBulk()", which is similar to procedure MS₋₋ cdfGateVerify(), begins at step 2302. Step 2304 processes the two parameters bnP and bnN in sequence. As parameter bnP is obtained, step 2306 stores the default expression iPar("bnPLib") as a temporary variable that is identified as "paramY". This temporary variable is used in verifying that the value of the parameter being verified matches the corresponding default value.

After "paramY" has been stored, at step 2308, Cadence SKILL command cdsParam() is used to evaluate the expression "iPar("bnPLib")", that is stored as "paramY", and compares the value for "paramY" with the value for parameter "bnP" that is being displayed on the active property form. In the example, "paramY" evaluates to "vpp|" and the value of the parameter "bnP" is "vpp|". Thus, it is determined that the value for parameter bnP being displayed is the default value. Step 2310 deletes the parameter value for bnP from the object database because the default value can be obtained from the parameter database when required. However, for the case where the value of parameter bnP is "vcc|", which is not the default value, the currently active value of the parameter bnP is maintained in the schematic object database 1635 for the current instance. Step 2312 then returns to step 2304 and a similar process is carried out for the parameter "bnN" using the default expression "iPar("bnNLib")". When both of the parameters bnP and bnN have been processed, step 2313 deletes "paramX" and "paramY". Then, step 2314 returns control to the schematic create engine 1605.

The circuit designer can select a different mode by changing "gateSize" 414 (FIG. 4) on the active property form 400. For example, if the circuit designer selects NP mode, then step 1720 calls procedure "MScdfGateModeCB( )" of the form transformer 1615 to update all of the parameter values on the active property form, and the procedure continues to step 1722. The procedure "MScdfGateModeCB()" determines if the parameter displayed by Cadence form displayer 1620 is an expression-type string whose value cannot be determined by evaluating the string. If so, Cadence SKILL command cdsParam() is used to calculate the corresponding value of the expression by using the global variables. Referring also to FIG. 25, in the example, labels 2504, 2506 and 2508 have been provided to indicate the default values for the parameters Wp, Lp and Ln. The numerical value of "10" is displayed for parameter Wn. In addition, the procedure "MScdfGateModeCB()" provides numerical values for parameters Wp, Lp and Ln and displays these values as the number "15" in data box 2510, the number "1.5" in data box 2512, and the number "1.5" in data box 2514, respectively.

More specifically, with reference to FIG. 21, the procedure "MScdfGateModeCB()" begins at step 2102. Step 2103 determines that an Add Component form is not being produced and flow continues to step 2104. Step 2104 determines that NP mode has been selected. Step 2108 selects parameter Wp and step 2110 determines that a default expression is being displayed. Step 2112 calculates a numerical value for the default value for parameter Wp by evaluating for default expression for the parameter Wp, which in the example is given by Wp=iPar(PNR)*iPar(Wn). In the example, the value for parameter "Wn" is "10" and the default value "PNR" is 1.5. Accordingly, step 2112 uses Cadence SKILL command cdsParam() to calculate a default value of "15" for the parameter Wp. This value is displayed in data box 2510 of the active property form 2500. The procedure returns to step 2108 which now selects parameter Wn. Step 2110 determines that a value of "10" is being displayed for parameter Wn and so the procedure jumps to step 2113 which returns to step 2108. In a similar manner, parameters Lp and Ln are processed in succession, and a numerical value is calculated by evaluating expressions, iPar("PDEFL") and iPar("NDEFL"), for parameters Lp and Ln, respectively, using the stored default values PDEFL and NDEFL. The numerical values of "1.5" for the parameters Lp and Ln are entered into data boxes 2512 and 2514 of the property form 2500.

Continuing with the illustration, it is now assumed that the circuit designer does not change any of these parameter values on the active property form 2500 and selects "Apply". When "Apply" 405 is selected, the procedure loops from step 1722 to step 1728 which calls procedure "MScdfGateDP()" to screen out any default values that are being displayed on the active property form. In the example, the values of parameters Wp, Lp and Ln are all default values.

Referring additionally to FIG. 22, step 2204 determines that NP mode is selected. The procedure "MScdfGateVerifyNP()" 2226 is called. Step 2228 selects parameter Wp and step 2230 stores the default expression for Wp, namely, "iPar(PNR)*iPar(Wn)". Then, at step 2232, Cadence SKILL command cdsParam() is used to evaluate this expression and the numerical value for the default expression "paramX" is compared with the numerical value for Wp that is being displayed on the active property form. In the example, the value "15" for the parameter Wp is the default value, and so, step 2234 of the procedure deletes this value from the schematic object database 1635. The procedure returns to step 2228 which selects parameter Wn. This parameter is processed in a similar manner, but the comparison operation performed by step 2232 determines that the value "10" is not the default value and accordingly, this value is maintained in the object database 1635. The procedure also determines that parameter values "1.5" for parameters Lp and Ln are default values and so these values are removed from the object database 1635. It is pointed out that although these parameter values have been deleted from the object database 1635, at this time, these parameters are still being displayed on the active property form, as shown in FIG. 25.

When all of the parameters have been processed, the procedure continues to procedure "MScdfGatePurgeExplicit()" steps 2238-2240 which is effective only in response to a change to mode NP from mode Explicit. Thus, in the example, the parameters, wpA, wnA, lpA and lnA, etc. have not yet been displayed for the current instance and so parameter values have not been applied to any of these parameters. The procedure is done, step 1730, unless the circuit designer modifies the design at step 1732 (FIG. 17).

Digressing, if for any reason, the circuit designer now closes the property form 2500 by selecting "Cancel" 407 on the active property form 2500, and then subsequently reopens property form 2500, the parameters for which values have been deleted are displayed as the appropriate default expressions on the active property form. Thus, the property form appears as property form 2600 which is illustrated in FIG. 26. Note that parameter Wn is displayed as having the numerical value of "10" and parameters Wp, Lp and Ln are displayed in terms of their default expressions.

Referring again to FIG. 17 and to the property form 2500 shown in FIG. 25, after selecting "Apply" 405 on the property form 2500, the circuit designer can make changes in the value of one or more parameters of the current instance, if desired. In response to the entry of a further parameter value or values, from step 1728, the procedure, at step 1732, loops back to whatever mode was active at the time design of the current instance was complete. In the example, NP mode at step 1722 was active. The circuit designer can make any additional changes in the current instance of the design that are desired.

For example, it is assumed that while in NP mode, at step 1722, the circuit designer now enters a non-default value of "20" for the drive strength parameter Wp as is illustrated into data box 2702 on the property form 2700 shown in FIG. 27. When "Apply" 405 is selected, this value is stored in the schematic object database 1635 and the procedure loops to step 1728 which calls the procedure "MScdfGateGateDP()", beginning at step 2202 (FIG. 22). The procedure continues as has been described above to screen out any parameter values that are default values. In the present example, the parameter values for Wn and Wp are retained in the schematic object database 1635. If the property form 2700 is closed and subsequently reopened, the form appears as shown in FIG. 27. When the design of the current instance is completed, control is returned to the schematic create driver 1605 at step 1730. The procedure can be reentered at step 1710 in response to the circuit designer placing another instance on the schematic.

Digressing once again, assuming, that while in NP mode and after the non-default parameter values for Wp and Wn have been entered on property form 2700 as has been described, the circuit designer selects N mode, from either step 1722 or step 1728. Procedure "MScdfGateModeCB()" is called, beginning at step 2102 (FIG. 21). The procedure passes through step 2103 and continues to step 2104 which determines that N mode is now selected and causes the property form for N mode to be displayed. Step 2106 causes the value for Wn to be displayed. In this embodiment, the non-default value for the parameter Wp is retained in the database, but is not displayed in N mode. When the circuit designer subsequently selects NP mode, the previously entered non-default value for Wp exists in the object database 1635 and will be displayed along with the non-default value for Wn. However, if "Apply" had been selected before switching to NP mode, the value for parameter Wp would have been deleted by MS₋₋ cdfGatePurgeNP() when the procedure MScdfGateDP() is called in response to selection of "Apply".

Referring again to FIG. 17, it is assumed now that while in NP mode, and for the property form 2700 shown in FIG. 27, the circuit designer selects Explicit mode. From step 1722, the procedure continues to step 1724 which calls procedure "MScdfGateModeCB()" to update the display, and the Explicit mode is entered at step 1726. The property form that is displayed is property form 2800, shown in FIG. 28. Referring additionally to FIG. 28, selection of Explicit mode causes the property form to be changed to additionally include parameter labels 2804-2818 and data boxes 2824-2838, resulting in a property form that is similar to property form 700 (FIG. 7). A portion of the form 2800 includes the information displayed on the property form 2700 that is illustrated in FIG. 27, including labels for parameters Wp, Wn, Lp and Ln, the corresponding data boxes that contain parameter values "20" and "10" and default expressions iPar("PDEFL") and iPar("NDEFL"). Note that parameter labels 2804-2810 have the suffix "A" and parameter labels 2812-2818 have the suffix "B". Note also that the data boxes 2824, 2827, 2832 and 2834 contain numerical values, all of which are "20" in the example, for the channel width parameter data for both p-channel and n-channel devices. Also, data boxes 2828, 2830, 2836, and 2838 contain numerical values, all of which are "1.5" in the example, for the channel length parameter data for both p-channel and n-channel devices.

More specifically, with reference to FIG. 21, the procedure "MScdfGateModeCB()" begins at step 2102 and step 2103 determines that an Add Component form is not being produced and flow continues to step 2104. Step 2104 determines that Explicit mode has been selected. It is pointed out that the library cdf parameter data contained in the database 936 from which the property forms for the current instance are created, includes the data needed to create parameter labels and data boxes for all of the parameters wpA, wnA, lpA, lnA, wpB, wnB, lpB, and lnB required for logic gate GNA0 for Explicit mode. Step 2114 of the procedure processes each of these parameters in sequence to determine for which, if any, of these parameters a parameter value exists, either obtaining the value from the object database 1635, or calculating the value using the appropriate default expressions and default values.

Step 2114 first selects the parameter "wpA". Step 2116 determines that no value for parameter "wpA" is stored in the object database 1635 and accordingly, step 2118 uses Cadence SKILL command cdsParam() to calculate a default value using the default expression iPar("Wp"), which evaluates to "20" in the example. This parameter value of "20" is displayed in data box 2824 for parameter wpA. A similar procedure is followed for each of the other parameters wnA, lpA, lnA, wpB, wnB, lpB, and lnB, calculating and displaying default values for these parameters as shown in FIG. 28. It is pointed out that in the case of wnA and wnB, the value of Wn is multiplied by "two" because their default expressions are "iPar(Wn)*2" for reasons discussed above. Consequently, parameters wnA and wnB both have a parameter value of "20". In the example, in addition to the non-default values for Wp and Wn, the procedure has entered a value "20" for parameters "wpA and wpB", as shown in data boxes 2824 and 2832 on property form 2800 and has entered a value "20" for parameters "wnA" and "wnB", as shown in data boxes 2826 and 2734 on property form 2800. Also, a value of "1.5" has been entered for parameters "lpA","lnA", "lpB" and "lnB" as shown in respective data boxes 2828, 2830, 2836, and 2838.

As has already been described above with reference to NP mode and the property form 2500 shown in FIG. 25, when "Apply" 405 is selected on the property form 2800, the procedure "MScdfGateDP()" (FIG. 22) is called to update the object database 1635 using the procedure MS₋₋ cdfGateVerify Explicit(). This procedure is similar to the procedures MS₋₋ cdfGateVerifyN() and MS₋₋ cdfGateNP(), except that at step 2248, "paramX" is stored for the default expression for each of the parameters wpA, wnA, lpA, lnA, wpB, wnB, lpB, and lnB, evaluated, and compared with the corresponding value displayed on the active property form. Because in the example all of these values correspond to the default values, step 2250 deletes these parameter values from the object database. If the property form is closed and subsequently reopened, the form appears as form 2900 (FIG. 29) because "Apply" has been selected calling procedure "MS₋₋ cdfGateVerifyExplicit()" 2242. Referring to FIG. 29, as can be seen, the data boxes 2924-2938 display the default expressions for the parameters wpA, wnA, lpA, lnA, wpB, wnB, lpB, and lnB.

Referring to FIG. 21, continuing with the illustration of the procedure, it is assumed that the circuit designer now selects NP mode. The procedure "MScdfGateModeCB()" is called to update the display of parameters. Step 2104 determines that NP mode is selected and steps 2108-2110 determine, sequentially, that numerical values are being displayed for parameters Wp and Wn. Also, step 2110 calculates numerical values for the default expressions for the parameters Lp and Ln and these values are displayed on the form.

Referring to FIG. 22, if, when NP mode is selected, the circuit designer selects "Apply", the procedure "MS₋₋ cdfGateVerifyNP()" 2226 is called, beginning at step 2228. The procedure "MS₋₋ cdfGateVeriyNP()" screens, the values of parameters Wp, Wn, Lp and Ln, in sequence, to remove from the object database 1635, those parameter values that are equal to respective default values as has been described. Then, at steps 2238-2241, procedure "MS₋₋ cdfGatePurgeExplicit()" 2220 deletes the parameter values for wpA, wnA, lpA, and lnA, and the parameter values for wpB, wnB, lpB, and lnB from the object database 1635 because these values are not displayed on the property form for NP mode.

If, on the other hand N mode is selected, the procedure is similar except that only parameter Wn is displayed. In the example, parameter Wn is displayed having a numerical value of "10". Initially, the non-default value for parameter Wp is retained in the database so that if the mode is changed back to the NP mode, for example a numerical value of "20" is displayed for parameter Wp. However, if "Apply" is selected, the parameter values for all of the parameters, other than parameter Wn, displayed while the Explicit mode was active are deleted from the object database 1635 by the procedures "MS₋₋ cdfGatePurgeNP()" 2214 and "MS₋₋ cdfGatePurgeExplicit()" 2220.

FIG. 30 is a listing of an exemplary code segment for the procedure "MScdfGateCreateBaseParam()". FIGS. 30A, 30B and 30C provide a listing of an exemplary code segment for the procedure "MS₋₋ cdfGateCreate". FIGS. 31 and 31A provide a listing of an exemplary code segment for the procedure "MS₋₋ cdfGateExplicit". The lines of the code are numbered consecutively in FIGS. 30A, 30B and 30C and in FIGS. 31 and 31A, and the lines of the code that begin with the notation ";" are comments.

FIG. 32 is a listing of an exemplary code segment for the procedure MScdfLibCreateBaseParam(). FIGS. 33, 33A and 33B provide a listing of an exemplary code segment for the procedure MScdfLibCreateParam(). FIG. 34 is a listing of an exemplary code segment for procedure MScdfLibCreateUserParam();

FIG. 35 is a listing of an exemplary code segment for the procedure MScdfGateIP(). FIG. 36 is a listing of an exemplary code segment for the procedure MScdfGateModeCB(). FIG. 37 is a listing of an exemplary code segment for the procedure MScdfGateDP(). FIGS. 38 and 38A are a listing of an exemplary code segment for the procedures MS₋₋ cdfGateVerifyN; MS₋₋ cdfGateVerifyNP; and MS₋₋ cdfGateVerifyExplicit. The lines of the code are numbered consecutively in FIGS. 38 and 38A. FIG. 39 is a listing of an exemplary code segment for the procedure MS₋₋ cdfGatePurgeNP. FIG. 40 is a listing of an exemplary code segment for the procedure MS₋₋ cdfGatePurgeExplicit. FIG. 41 is a listing of an exemplary code segment for the procedure MS₋₋ cdfGateVerifyBulk(). In FIGS. 35-41, any lines that begin with the notation ";" are comments. 

What is claimed is:
 1. A system for producing a schematic of an integrated circuit in a plurality of design modes using a Computer-aided design apparatus, the system comprising:a design tool for creating the schematic of the integrated circuit; and a single cell library including a single parameter database wherein the single parameter database includes base level component description format parameter data to provide al information for a property form user interface to display one or more labels and one or more base level component description format parameter values for a plurality of logic gates and wherein the single parameter database allows the schematic containing at least one of the logic gates to be automatically created in each one of the plurality of design modes using the design tool wherein a first one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of one single drive strength for only one type of device that forms the plurality of logic gates, wherein a second one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of drive strengths for two types of devices that form the plurality of logic gates, and wherein a third one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of a plurality of parameters of all types of the devices that form the plurality of logic gates.
 2. The system of claim 1 further comprising a user interface for allowing a user to specify one of the plurality of design modes.
 3. The system of claim 2 wherein the user interface further comprises a first set of labels and fields for information provided by the design tool.
 4. The system of claim 3 wherein the user interface further comprises a second set of labels and fields for one or more parameters wherein the second set of labels and fields provided depends on the design mode selected by the user.
 5. The system of claim 1 wherein the schematic of the integrated circuit represents a static random access memory device.
 6. The system of claim 1 wherein the schematic of the integrated circuit represents a dynamic random access memory device.
 7. The system of claim 1 wherein the single parameter database stores one or more labels and one or more parameter values for a plurality of logic gates used to design a static random access memory device and a dynamic random access memory device.
 8. A system for creating a design schematic for an integrated circuit using a schematic design tool, the system comprising:a single cell library including a single parameter database wherein the single parameter database includes base level component description format parameter data to provide all information for a property form user interface to display one or more labels and one or more base level component description format parameter values for a plurality of logic gates and wherein the single parameter database allows the schematic containing at least one of the logic gates to be automatically created in each one of a plurality of design modes; wherein a first one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of one single drive strength for only one type of device that forms the plurality of logic gates, wherein a second one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of drive strengths for two types of devices that form the plurality of logic gates, and wherein a third one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of a plurality of parameters of all types of the devices that form the plurality of logic gates; and a user interface allowing a user to specify one of the plurality of design modes such that when the user specifies one of the design modes for one the logic gates the user interface is automatically updated to display the base level component description format parameters from the parameter database for the design mode.
 9. The system of claim 8 wherein the six parameter database stores the base level component description format parameters for a plurality of logic gates used to design a static random access memory device and a dynamic random access memory device.
 10. A method of producing a schematic of an integrated circuit using a computer-aided design apparatus, the method comprising the steps of:receiving a logic gate selection for a logic gate to be placed on the schematic wherein the logic gate selection is received by a single cell library including a single parameter database wherein the single parameter database includes base level component description format parameter data to provide all information for a property form to display one, or more labels and one or more base level component description format parameter values for a plurality of logic gates, and wherein the parameter database allows the schematic containing at least one of the logic gates to be automatically created in each one of a plurality of design modes; receiving a design made selection for one of the plurality of design modes, wherein a first one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of one single drive strength for only one, type of device that forms the plurality of logic gates wherein a second one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of drive strengths for two types of devices that form the plurality of logic gates, and wherein a third one of the plurality of design modes provides the labels and the parameter values for the plurality of topic gates in terms of a plurality of parameters of all types of the devices that form the plurality of logic gates; providing a property form having one or more base level component description format parameters for the logic gate and the design mode wherein the base level component description format parameters displayed on the property form for each one of the design modes are obtained from the single parameter database; and placing at least one of the plurality of logic gates on the schematic.
 11. The method of claim 10, wherein the step of providing the property form displays one or more default values for the parameters.
 12. The method of claim 11, further comprising the step of substituting one or more custom values for the default values for the parameters.
 13. The method of claim 12, wherein the step of substituting the one or more custom values is preformed by a user manually changing settings on the property form.
 14. A computer-readable medium having computer-executable instructions for performing the steps recited in claim
 10. 15. A method of generating a property form having one or more parameter labels and one or more parameter values for a logic gate used in a schematic for an integrated circuit that is being designed using a computer-aided design apparatus, the method comprising the steps of:providing a single cell library including a single parameter database wherein the single parameter database includes base level component description format parameter data to provide all information for a properly form user interlace to display one or more labels and one or more base level component description format parameter values for a plurality of logic gates and wherein the single parameter database allows the schematic containing at least one of the logic gates to be automatically created in each one of the plurality of design modes; receiving a mode indicator indicating one of a plurality of design modes wherein a first one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of one single drive strength for only one type of device that forms the plurality of logic gates, wherein a second one of the plurality of design modes provides the labels and the parameter vales for the plurality of logic gates in terms of drive strengths for two types of devices that form the plurality of logic gates, and wherein a third one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of a plurality of parameters of all types of the devices that form the plurality of logic gates; accessing the single parameter database by a user interfaces; transforming the parameter labels and the parameter values to form at least one of the plurality of logic gates in response to the mode indicator received; and automatically displaying the base level component description format parameter labels and the base level component description format parameter values in response to the mode indicated for a current instance of at least one of the logic.
 16. The method of claim 15 wherein the step of displaying displays the parameter values as numeric values.
 17. The method of claim 15 wherein the step of displaying displays the parameter values as default expressions.
 18. The method of claim 17 further comprising the step of customizing the default expression.
 19. A computer-readable medium having computer-executable instructions for performing the steps recited in claim
 15. 20. A computer-readable medium having computer-executable components for producing a schematic of an integrated circuit in a plurality of design modes using a computer-aided design apparatus, the computer-executable components comprising:a design tool component for creating a schematic of an integrated circuit; and a single cell library component including a single parameter database component wherein the single parameter database includes base level component description format parameter data to provide all information for a property form user interface to display one or more labels and one or more base level component description format parameter values for a plurality of logic gates and wherein the single parameter database component allows the schematic containing at least one of the logic gates to be automatically created in of the plurality of design modes using the design tool component wherein a first one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of one single drive strength for only one type of device that forms the plurality of logic gates, wherein a second one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of drive strengths for two types of devices that form the plurality of logic gates and wherein a third of logic gates in terms of a plurality of parameters of all types of the devices that form the plurality of logic gates.
 21. The computer-readable medium of claim 20 having further computer-executable components comprising a user interface component for allowing a user to specify one of the plurality of design modes.
 22. The system of claim 21 wherein the parameter database component stores labels and parameter values for logic gates used to design a static random access memory device and a dynamic random access memory device.
 23. A display device having rendered thereon a property form for producing a logic gate in a schematic of a integrated circuit in one of a plurality of design modes using a computer-aided design apparatus, comprising:a single cell library including a single parameter database wherein the single parameter database includes base level component description format parameter data to provide all information for a property form user interface to display one or more labels and one or more base level component description format parameter values for a plurality of logic gates and wherein the single parameter database allows the schematic containing at least one of the logic gates to be automatically created in each one of the plurality of design modes; and user interface allowing a user to specify one of the plurality of design nodes such that when the user specifies one of the design modes for one of the logic gates the user interface is automatically updated to display the base level component description format parameters from the single parameter database for the design mode, wherein the user interface further comprises:a first region having data produced by a schematic design program, and a second region of the property form having labels aid values for parameters wherein the labels and values depend on the one of the plurality of design modes specified by a user wherein a first one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of one single drive strength for only one type of device that forms the plurality of logic gates, wherein a second one of the plurality of design modes provides the labels and the parameter values for the plurality of logic gates in terms of drive strengths for two types of devices that form the plurality of logic gates and wherein a third one of the plurality of design modes provides the labels end the parameter values for the plurality of logic gates in terms of a plurality of parameters of all types of the devices that form the plurality of logic gates. 